# 组合应用引用函数表达式
用户在编辑设计组合应用时，可以通过引用函数表达式的方式快速配置连接器的配置信息，帮助用户便捷高效的设计组合应用。
组合应用中的函数表达式使用方法如[图1]所示。
图1函数表达式的使用方法   
![](https://support.huaweicloud.com/usermanual-roma/zh-cn_image_0000002532874249.png "点击放大")
#### 函数表达式的分类
组合应用提供数学、数组、字符串、xml处理、json处理、节点输出、加解密、日期和时间、编解码、进制转换、比较共11种类型的函数表达式。
表1函数表达式 
| 分类          | 函数表达式                                                                                      | 说明                                                                                                                                                                                                                                                                                 |
|:---|:---|:---|
| 数学（4个）       | sum(array arr)                                                                                 | 返回数组中所有数字的和。例：${sum(3,5,6)}，返回14。                                                                                                                                                                                                                                                 |
| 数学（4个）       | avg(array arr)                                                                               | 返回数组中所有数字的平均值。例：${avg(2,4)}，返回3。                                                                                                                                                                                                                                                   |
| 数学（4个）       | mod(number num1, number num2)                                                                 | 执行模运算，返回num1除以num2后的余数。                                                                                                                                                                                                                                                             |
| 数学（4个）       | randomint(number num)                                                                        | 返回一个介于0和提供的数字（包括）之间的随机整数。                                                                                                                                                                                                                                                         |
| 数组（1个）      | divideBy(array arr, number size)                                                            | 根据size划分数组arr为多个数组。                                                                                                                                                                                                                                                              |
| 字符串（34个）  | uuid()                                                                                      | 生成由字母和数字组成的随机uuid。                                                                                                                                                                                                                                                                 |
| 字符串（34个）  | upper(string str)                                                                           | 将字符串全部转换为大写字符。例：${upper('abc')}，返回"ABC"。                                                                                                                                                                                                                                           |
| 字符串（34个）  | lower(string str)                                                                           | 将字符串全部转换为小写字符。例：${lower('ABC')}，返回"abc"。                                                                                                                                                                                                                                           |
| 字符串（34个）  | camelize(string str)                                                                         | 使用驼峰式大小写转换str中的单词，删除所有空格，并将除第一个单词外的每个单词的首字母转换为大写。例：${camelize('aaa_bbb_ccc')}，返回"aaaBbbCcc"。                                                                                                                                                                                         |
| 字符串（34个）  | dasherize(string str)                                                                         | 使用kebab-case转换str中的单词，将str中的所有字母转换为小写，将所有空格转换为连字符(-)。例：${dasherize('Aaa Bbb Ccc')}，返回"aaa-bbb-ccc"。                                                                                                                                                                                 |
| 字符串（34个）  | capitalize(string str)                                                                      | 使用大小写转换str中的单词，将每个单词的第一个字母变为大写，其余字母变为小写。例：${capitalize('aaaBbbCcc')}，返回"Aaa Bbb Ccc"。                                                                                                                                                                                               |
| 字符串（34个）  | charCode(string char)                                                                       | 将char转换为字符编码。例：${charCode('hello')}，返回104。                                                                                                                                                                                                                                          |
| 字符串（34个）  | fromCharCode(number charCode)                                                              | 将字符编码转换为字符串。例：${fromCharCode(104)}，返回"h"。                                                                                                                                                                                                                                            |
| 字符串（34个）  | charCodeAt(string str, number index)                                                        | 返回str中索引处的字符编码。例：${charCodeAt('hello', 2)}，返回108。                                                                                                                                                                                                                                     |
| 字符串（34个）  | isAlpha(string str)                                                                         | 返回一个布尔值，确定提供的字符串是否只包含英文字母。例：${isAlpha('abc')}，返回true; ${isAlpha('a-b-c')}，返回false。                                                                                                                                                                                                 |
| 字符串（34个）  | isAlphanumeric(string str)                                                                    | 返回一个布尔值，确定提供的字符串是否只包含英文字母或数字。例：${isAlphanumeric('aBc123')}，返回true；${isAlphanumeric('aBc-123')}，返回false。                                                                                                                                                                            |
| 字符串（34个）  | isNumeric(string str)                                                                        | 返回一个布尔值，确定提供的字符串是否只包含数字。例：${isNumeric('123')}，返回true；${isNumeric('1-2-3')}，返回false。                                                                                                                                                                                                  |
| 字符串（34个）  | isLowerCase(string str)                                                                    | 返回一个布尔值，确定str是否全部为小写。例：${isLowerCase('abc')}，返回true；${isLowerCase('aBc')}，返回false。                                                                                                                                                                                                  |
| 字符串（34个）  | isUpperCase(string str)                                                                     | 返回一个布尔值，确定str是否全大写。例：${isUpperCase('ABC')}，返回true；${isUpperCase('AbC')}，返回false。                                                                                                                                                                                                    |
| 字符串（34个）  | isWhitespace(string str)                                                                     | 返回一个布尔值，确定str是否只包含空格。例：${isWhitespace(' ')}，返回true；${isWhitespace('a b c')}，返回false。                                                                                                                                                                                               |
| 字符串（34个）  | leftPad(string str, number offset)                                                           | 如果字符串小于偏移长度，则用空格填充str的左侧。例：${leftPad('abc', 4)}，返回"abc"。                                                                                                                                                                                                                           |
| 字符串（34个）  | rightPad(string str, number offset)                                                          | 如果字符串小于偏移量长度，则用空格补全str的右侧。例：${rightPad('abc', 4)}，返回"abc "。                                                                                                                                                                                                                        |
| 字符串（34个）  | substring(string str, number startIndex, number endIndex)                                      | 从字符串中提取位于区间(startIndex, endIndex)的子字符串。                                                                                                                                                                                                                                          |
| 字符串（34个）  | substring(string str, number startIndex)                                                      | 从字符串中提取位于区间startIndex至字符串结束的子字符串。                                                                                                                                                                                                                                                |
| 字符串（34个）  | substringAfter(string str, string separator)                                                 | 获取str在第一次出现分隔符之后的子字符串。例：${substringAfter('a,b,c,d', ',')}，返回"b,c,d"。                                                                                                                                                                                                               |
| 字符串（34个）  | substringAfterLast(string str, string separator)                                               | 获取str中分隔符最后一次出现之后的子字符串。例：${substringAfterLast('a,b,c,d', ',')}，返回"d"。                                                                                                                                                                                                                |
| 字符串（34个）  | substringBefore(string str, string separator)                                                 | 获取str中第一次出现分隔符之前的子字符串。例：${substringBefore('a,b,c,d', ',')}，返回"a"。                                                                                                                                                                                                                    |
| 字符串（34个）  | substringBeforeLast(string str, string separator)                                           | 获取str中分隔符最后出现之前的子字符串。例：${substringBeforeLast('a,b,c,d', ',')}，返回"a,b,c"。                                                                                                                                                                                                           |
| 字符串（34个）  | unwrap(string str, string wrapper)                                                            | 返回没有包装器文本的str。包装器文本是str前面和/或后面的值。例：${unwrap("/test/", "/")}，返回 "test"。                                                                                                                                                                                                             |
| 字符串（34个）  | withMaxSize(string str, number size)                                                        | 限制str的大小。例：${withMaxSize('abcd', 3)}，返回"abc"。                                                                                                                                                                                                                                        |
| 字符串（34个）  | wrapIfMissing(string str, string wrapper)                                                    | 如果str没有被包装，则将包装器添加到str的前面和末尾。如果包装器在开始或结束时已经存在，则只更新缺失端。例：${wrapIfMissing("/test", "/")}，返回"/test/"。                                                                                                                                                                                  |
| 字符串（34个）  | wrapWith(string str, string wrapper)                                                        | 将包装器添加到str的前面和后面。例：${wrapWith("test", "/")}，返回"/test/"。                                                                                                                                                                                                                             |
| 字符串（34个）  | ordinalize(number num)                                                                         | 将num转换为有序字符串格式，例如1st, 2nd, 3rd等。例：${ordinalize(3)}，返回 3rd。                                                                                                                                                                                                                         |
| 字符串（34个）  | appendIfMissing(string str, string value)                                                   | 如果str不以value结尾，则在str后面加上value。例：${appendIfMissing('ab', 'cd')}，返回"abcd"。                                                                                                                                                                                                            |
| 字符串（34个）  | prependIfMissing(string str, string value)                                                   | 如果str不以value开头，则在str前面加上value。例：${prependIfMissing('cd', 'ab')}，返回"abcd"。                                                                                                                                                                                                           |
| 字符串（34个）  | repeat(string str, number times)                                                            | 重复给定的次数。例：${repeat('abc', 3)}，返回"abcabcabc"。                                                                                                                                                                                                                                       |
| 字符串（34个）  | replace(string str, String subStr\[, string replaceStr\])                                    | 删除字符串中所匹配的字符串。例如：replace('Hello iWorldi!', 'i')，返回值为Hello World!；将字符串中所匹配的字符串替换为指定字符串。例如：replace('Hella Warld!', 'a', 'o')，返回值为"Hello World!"。                                                                                                                                      |
| 字符串（34个）  | join(array arr, String str)                                                                  | 将数组中的多个字符串连接起来，并使用指定的分隔符分隔每个字符串。例如：join(\['hello','i','you'\], ';')，返回值为"hello;i;you"。                                                                                                                                                                                              |
| 字符串（34个）  | concat(String str1, String str2, ...)                                                        | 将多个字符串拼接成一个字符串。例如：concat('Hello', ' ', 'World', '!')，返回值为"Hello World!"。                                                                                                                                                                                                            |
| xml处理（4个）    | xpath(string xml, string xpath, string resultType='string', string namespace='', int timeout=5) | 返回与 XPath（XML 路径语言）表达式匹配的节点或值。默认返回结果类型为string。可选指定返回结果类型为string, integer, boolean或array。xpath执行超时时间默认是5s, 最大支持可配15s。例如：${xpath(getStepPayload('123'), '//name', 'array', '', 5)}，返回值为List\<Dom\>。注意变量点选时不要采用嵌套$模板，错误示例：${xpath(${getStepPayload('123')})}。                          |
| xml处理（4个）    | parseXML(string xml)                                                                        | 解析xml，默认返回结果类型为dom。例如：${parseXML(getStepPayload('123'))}，返回值为dom对象。                                                                                                                                                                                                                 |
| xml处理（4个）    | toXMLBytes(Dom xml)                                                                            | 转换xml为二进制类型，默认返回结果类型为bytes。例如：${toXMLBytes(parseXML(getStepPayload('123')))}，返回值为bytes。                                                                                                                                                                                            |
| xml处理（4个）    | toXMLString(Dom xml)                                                                          | 转换xml为字符串，默认返回结果类型为string。例如：${toXMLString(parseXML(getStepPayload('123')))}，返回值为string。                                                                                                                                                                                           |
| json处理（3个）  | parseJSON(string json)                                                                       | 解析json，默认返回结果类型为json对象。例如：parseJSON('{"a":1}')，返回值为json对象。                                                                                                                                                                                                                       |
| json处理（3个）  | toJSONBytes(string json)                                                                      | 转换json为二进制类型，默认返回结果类型为bytes。例如：${toJSONBytes('{"a":1}')}，返回值为bytes。                                                                                                                                                                                                                |
| json处理（3个）  | toJSONString(object json)                                                                    | 转换json为字符串，默认返回结果类型为string。例如：${toJSONString(parseJSON(getStepPayload('123'))\['key'\])}，返回值为string。                                                                                                                                                                               |
| 节点输出（2个）   | getStepPayload(string stepId)                                                                | 获取对应节点的输出。例如：${getStepPayload('123')}，返回值节点id为123的节点的输出。                                                                                                                                                                                                                            |
| 节点输出（2个）   | getStepProperty(string stepId, string propName)                                               | 获取对应节点的name为propName的属性值。例如：${getStepProperty('123', 'xml')}，返回值为节点id为123的节点的xml属性值。                                                                                                                                                                                                |
| 加解密（4个）    | hash(string value, string algorithm)                                                        | 使用支持的算法计算value的散列值。算法必须是MD2、MD5、SHA-1、SHA-256、SHA-384、SHA-512中的一种。例：${hash('abcd', 'MD5')}，返回"e2fc714c4727ee9395f324cd2e7f331f"。                                                                                                                                                     |
| 加解密（4个）    | hmac(string value, string secret, string algorithm)                                            | 使用提供的值、密钥和散列函数算法生成基于散列的消息验证码。必须是HmacSHA1、HmacSHA256或HmacSHA512中的一种。例：${hmac('abcd', 'test', 'HmacSHA1')}，返回"bcde772eafae465fe002b2bbb5c68d66da0d241a"。                                                                                                                               |
| 加解密（4个）    | encrypt(string value, string secret, string transformation)                                  | 使用指定的JDK和提供的密钥对值进行加密。使用Base64将加密转换为可读的格式。例：${encrypt('Hello', '8byteKey', 'DES/CBC/PKCS5Padding')}，返回"Ic3THvsowTV3itOf40K56w=="。                                                                                                                                                   |
| 加解密（4个）    | decrypt(string value, string secret, string algorithm, string mode, string padding)          | 使用指定的JDK和提供的密钥解密Base64值。例：${decrypt("Ic3THvsowTV3itOf40K56w==", "8byteKey", "DES/CBC/PKCS5Padding")}，返回"Hello"。                                                                                                                                                                   |
| 日期和时间（24个） | now()                                                                                        | 返回当前的日期时间。例：${now()}，返回"2025-03-26T03:17:37"。                                                                                                                                                                                                                                     |
| 日期和时间（24个） | compare(string datetime1, string datetime2)                                                 | 如果datetime1 \> datetime2返回1，如果datetime1 \< datetime2返回-1，如果datetime1 == datetime2返回0。例：${compare('2025-03-26T05:20:30Z', '2025-03-27T05:20:30Z')}，返回 -1。                                                                                                                           |
| 日期和时间（24个） | atBeginningOfDay(string datetime)                                                          | 返回给定时间的午夜时间值。例：${atBeginningOfDay('2025-03-26T05:20:30Z')}，返回"2025-03-26T00:00:00Z"。                                                                                                                                                                                                  |
| 日期和时间（24个） | atBeginningOfHour(string datetime)                                                           | 返回给定的日期时间，分钟数和秒数设置为0。例：${atBeginningOfHour('2025-03-26T05:20:30Z')}，返回"2025-03-26T05:00:00Z"。                                                                                                                                                                                      |
| 日期和时间（24个） | atBeginningOfMonth(string datetime)                                                          | 返回给定的日期时间，日期设置为月份的第一天，时间设置为午夜。 例：${atBeginningOfMonth('2025-03-26T05:20:30Z')}，返回"2025-03-01T00:00:00Z"。                                                                                                                                                 |
| 日期和时间（24个） | atBeginningOfWeek(string datetime)                                                           | 返回当前星期第一天的给定的日期时间，并将时间设置为午夜。例：${atBeginningOfWeek('2025-03-26T05:20:30Z')}，返回"2025-03-23T00:00:00Z"。                                                                                                                                                                                |
| 日期和时间（24个） | atBeginningOfYear(string datetime)                                                          | 返回一年中的第一个给定的日期时间，并将时间设置为午夜。例：${atBeginningOfYear('2025-03-26T05:20:30Z')}，返回"2025-01-01T00:00:00Z"。                                                                                                                                                                                  |
| 日期和时间（24个） | changeTimeZone(string datetime, string timezone)                                             | 更改日期时区，这通常会导致本地日期时间的更改。例：${changeTimeZone('2024-05-22T08:25:16Z', 'UTC')}，返回"2024-05-22T08:25:16Z"。                                                                                                                                                                                  |
| 日期和时间（24个） | daysBetween(string datetime1, string datetime2)                                             | 返回datetime1和datetime2之间的天数。例：${daysBetween('2024-05-22T08:25:16Z', '2024-05-28T18:25:16Z')}，返回6。                                                                                                                                                                                   |
| 日期和时间（24个） | format(string datetime, string outputFormat)                                                  | 给定一个datetime，将其转换为指定的输出格式。例：${format('2024-05-22T08:25:16Z', 'yyyy/MM/dd HH:mm')}，返回"2024/05/22 08:25"。                                                                                                                                                                              |
| 日期和时间（24个） | datetimeFormat(string datetime, string outputFormat)                                        | 给定一个datetime，将其转换为指定的输出格式。例如：datetimeFormat('2024-05-22T08:25:16Z', 'yyyy/MM/dd HH:mm')，返回值为2024/05/22 08:25。                                                                                                                                                                       |
| 日期和时间（24个） | isLeapYear(string datetime)                                                                  | 返回一个布尔值，表示datetime是否为闰年。例：${isLeapYear('2024-05-22T08:25:16Z')}，返回 true。                                                                                                                                                                                                          |
| 日期和时间（24个） | plus(string datetime, string period)                                                          | 按照给定的类型为datetime添加日期。例：${plus('2024-05-22T08:25:16Z', 'P1D')}，返回"2024-05-23T08:25:16Z"。                                                                                                                                                                                              |
| 日期和时间（24个） | minus(string datetime, string period)                                                           | 按照给定的类型为datetime减去日期。例：${minus('2024-05-22T08:25:16Z', 'P1D')}，返回"2024-05-21T08:25:16Z"。                                                                                                                                                                                            |
| 日期和时间（24个） | parse(string\|number datetime, string inputFormat)                                          | 使用输入格式解析datetime，并以默认格式返回值。如果使用epoch或timestamp值作为datetime，则可以使用"epoch"或"timestamp"作为inputFormat。例：${parse('12/31/1990 10:10:10', 'MM/dd/yyyy HH:mm:ss')}，返回"1990-12-31T10:10:10Z"。                                                                                                 |
| 日期和时间（24个） | toLocalDate(string datetime)                                                                | 将日期转换为本地日期。例：${toLocalDate('2024-05-22T08:25:16Z')}，返回"2024-05-22"。                                                                                                                                                                                                                 |
| 日期和时间（24个） | toLocalDateTime(string datetime)                                                              | 将日期时间转换为本地日期时间。例：${toLocalDateTime('2024-05-22T08:25:16Z')}，返回"2024-05-22T08:25:16"。                                                                                                                                                                                              |
| 日期和时间（24个） | toLocalTime(string datetime, string format)                                                 | 将时间转换为本地时间。例：${toLocalTime('2024-05-22T08:25:16Z')}，返回"08:25:16"。                                                                                                                                                                                                                 |
| 日期和时间（24个） | today()                                                                                     | 返回当天午夜的时间。                                                                                                                                                                                                                                                                          |
| 日期和时间（24个） | tomorrow()                                                                                   | 返回第二天午夜的时间。                                                                                                                                                                                                                                                                        |
| 日期和时间（24个） | yesterday()                                                                                   | 返回前一天午夜的时间。                                                                                                                                                                                                                                                                        |
| 日期和时间（24个） | dayOfWeek(string datetime)                                                                   | 返回当前时间属于一周中的第几天。例如：dayOfWeek('2025-04-05T19:21:45.111Z')，返回值为6；dayOfWeek('2025-04-05')}，返回值为6。                                                                                                                                                                                     |
| 日期和时间（24个） | dayOfMonth(string datetime)                                                                   | 返回当前时间属于一月中的第几天。例如：dayOfMonth('2025-04-05T19:21:45.111Z')，返回值为5；dayOfMonth('2025-04-05')}，返回值为5。                                                                                                                                                                                    |
| 日期和时间（24个） | dayOfYear(string datetime)                                                                  | 返回当前时间属于一年中的第几天。例如：dayOfYear('2025-04-05T19:21:45.111Z')，返回值为95；dayOfYear('2025-04-05')}，返回值为95。                                                                                                                                                                                  |
| 编解码（2个）   | encode(string data, string encoding="UTF-8")                                                | 使用提供的编码方案将字符串转换为application/x-www-form-urlencoded格式，以获取不安全的字节。默认编码为UTF-8。例：${encode('Hello，世界', encoding="UTF-8")}，返回"Hello%EF%BC%8C%E4%B8%96%E7%95%8C"。                                                                                                                            |
| 编解码（2个）   | decode(string data, string encoding="UTF-8")                                               | 使用特定的编码方案解码application/x-www-form-urlencoded字符串。所提供的编码用于确定以"%xy"形式的任意连续序列表示哪些字符。例：${decode('Hello%EF%BC%8C%E4%B8%96%E7%95%8C', encoding="UTF-8")}，返回"Hello，世界"。                                                                                                                       |
| 进制转换（9个）    | fromBase64(string value)                                                                     | 将base64转换为值。例：${fromBase64('SGVsbG8=')}，返回"Hello"。                                                                                                                                                                                                                                  |
| 进制转换（9个）    | toBase64(any value)                                                                           | 将value转换为base64。当前不支持直接传入数组以及类似${083xxx\|param}格式的payload关键字；数组格式需要添加单引号。如下图： ![](https://support.huaweicloud.com/usermanual-roma/zh-cn_image_0000002500954334.png "点击放大")  例：${toBase64('Hello')}，返回"SGVsbG8="。 |
| 进制转换（9个）    | fromHex(string value)                                                                          | 将十六进制转换为值。例：${fromHex(13)}，返回19。                                                                                                                                                                                                                                                    |
| 进制转换（9个）    | toHex(any value)                                                                             | 将value转换为十六进制。例：${toHex(19)}，返回13。                                                                                                                                                                                                                                                  |
| 进制转换（9个）    | fromBinary(number value)                                                                      | 将值从二进制转换为十进制。例：${fromBinary(101)}，返回5。                                                                                                                                                                                                                                            |
| 进制转换（9个）    | fromHex(number value)                                                                       | 将值从十六进制转换为十进制。例：${fromHex(13)}，返回19。                                                                                                                                                                                                                                              |
| 进制转换（9个）    | fromRadixNumber(number value, number baseAsBinary)                                          | 将输入值转换通过指定的进制转换为十进制。例：${fromRadixNumber(101, 2)}，返回5。                                                                                                                                                                                                                               |
| 进制转换（9个）    | toBinary(number value)                                                                       | 将值从十进制转换为二进制。例：${toBinary(8)}，返回 1000。                                                                                                                                                                                                                                            |
| 进制转换（9个）    | toRadixNumber(number value, number baseAsDecimal)                                            | 将值转换为指定的进制。例：${toRadixNumber(5, 2)}，返回101。                                                                                                                                                                                                                                         |
| 比较（1个）      | equal(any value1, any value2)                                                                | 判断两个对象转换成的字符串后是否相等。例如：equal('Hello World!', 'Hello World!')，返回值为true。                                                                                                                                                                                                               |
   
