
# 内置函数
在智能IVR流程编排过程中，可以依据实际需要使用内置函数对流程中的变量进行分割、截取等操作。
- 使用如下内置函数进行多重运算时，子表达式要加括号。
- 条件表达式中，使用==判断，仅适用于字符和数字，不适用于对象和列表(null判断除外)。
表1内置列表 
| 函数名                             | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|
| length()                        | 获取字符串长度。 使用场景示例：例如有一个流程变量Answer，FLOW.Answer的值为：abcde，您可以通过如下表达式获取流程变量Answer的字符串长度：FLOW.Answer.length()，结果为5。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| size()                          | 当变量为数组和对象时获取其中的元素个数。 使用场景示例：例如有一个流程变量Answer，FLOW.Answer的值为：\[1，2，3，4，5\]，您可以通过如下表达式获取流程变量Answer的字符串长度：FLOW.Answer.size()，结果为5。 说明： 流程变量定义的对象和数组，若没有设置缺省值也没有赋值，则值不会为null，且size为0。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| substring(beginIndex, endIndex) | 字符串截取。 - beginIndex：从0开始，0表示第1个字符，表示从第几个字符开始截取。  - endIndex：表示到第几个字符结束截取，不包含endIndex对应的字符。   使用场景示例：例如有一个流程变量Answer，FLOW.Answer的值为："orderid":"12345"，如果您需要获取流程变量Answer的12345，请使用如下表达式：FLOW.Answer.substring(11, 16)                                                                                                                                                                                                                                                                                                |
| startsWith("xxx")               | 判断变量是否以某个字符串开头。 使用场景示例：例如有一个流程变量Answer，FLOW.Answer的值为：abcde，如果您需要判断流程变量Answer是否以字符a开头，请使用如下表达式：FLOW.Answer.startsWith("a")，结果为是，通常用于条件表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| endsWith("xxx")                 | 判断变量是否以某个字符串结尾。 使用场景示例：例如有一个流程变量Answer，FLOW.Answer的值为：abcde，如果您需要判断流程变量Answer是否以字符e结尾，请使用如下表达式：FLOW.Answer.endsWith("e")，结果为是，通常用于条件表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| null值的判断                        | 判断变量是否等于null值。 使用场景示例：例如有一个流程变量Answer，FLOW.Answer的值为：null。如果您需要判断流程变量Answer是否为null，请使用如下表达式：FLOW.Answer==null或FLOW.Answer!=null                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| 加法运算：+                          | 可通过加法运算进行如下运算： - 字符串+字符串=字符串拼接  - 字符串+整型=字符串拼接  - 整型+整型=加法计算   使用场景示例：例如有一个流程变量Str，FLOW.Str的值为："123"，有一个流程变量Num，FLOW.Num的值为：123， 如果您使用如下表达式：FLOW.Str+FLOW.Num，结果为字符串："123123"。 |
| 除法运算：/                          | 对数字进行除法。 使用场景示例：例如有一个流程变量Num1，一个流程变量Num2，如果您使用如下表达式：FLOW.Num1/FLOW.Num2，将其结果赋值给另外一个流程变量result，要求流程变量result必须为浮点型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| put()                           | 给对象添加属性。 使用场景示例：例如有一个对象型的流程变量FLOW.person值为{"name":"Jack"}，那么可以在缓存变量处，通过FLOW.person.put("age","18")为FLOW.person添加age属性。同时，将结果{"name":"Jack","age":"18"}缓存到任何对象型的变量。若有一个整型的流程变量FLOW.age值为18，也可通过FLOW.person.put("age",FLOW.age)的方式，添加结果为{"name":"Jack","age":18}。 说明： FLOW.person.put(key,value)，key和value都可以为变量名。若value为常量，则不管是否加了双引号，都会默认将属性值设置为字符型，若value为变量，则以变量的类型为准。                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| add()                           | 给列表添加元素。 使用场景示例：例如有一个列表型的流程变量FLOW.arrayList值为\[1\]，那么可以在缓存变量处，通过FLOW.arrayList.add(2)为FLOW.arrayList的末尾添加一个值为"2"的元素。同时，将结果\[1,"2"\]缓存到任何列表型的变量。若有一个整型流程变量FLOW.num值为"18"，也可通过FLOW.arrayList.add(FLOW.num)的方式，添加结果为\[1,18\]。 说明： FLOW.arrayList.add(value)，value可以为变量名。若value为常量，则不管是否加了双引号，都会默认将值设置为字符型，若value为变量，则以变量的类型为准。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
   
表2字符串操作方法 
| 函数名               | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|
| strSplit()        | 根据给定的分割符拆分字符串。 函数返回对象为数组类型，保存拆分后的字符串数组。包含两个参数：第一个为待拆分的字符串，第二个为分割符。 注意： 25.200.0版本以前正则特殊字符需要使用方括号包裹，25.200.0版本（含）以后正则特殊字符不需要使用方括号包裹。但为兼容历史数据，使用方括号包裹的单个特殊字符也会当做单个特殊字符处理，比如\[.\]和.表示的含义一样，请注意不要使用方括号包裹某个字符（比如\[.\]）作为实际的分隔符！ 使用场景示例： 例如有一个字符型的流程变量FLOW.str值为"aa,cc,dd,ee"，那么可以在方法调用处，通过调用strSplit方法，根据给定的分割符","拆分字符串。同时，将分割结果缓存到任何列表型的变量(FLOW.array)。该方法调用的参数支持变量赋值和手动赋值。方法参数填入时不需要加引号(下同)。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351647.png) |
| strSubstring()    | 提取子字符串。 函数返回对象为字符串类型，为截取的子字符串。包含三个参数：第一个为待截取的字符串，第二个为开始下标（整型），第三个为结束下标（整型）。（下标从0开始，不包含结束下标字符）。 使用场景示例： 例如有一个字符型的流程变量FLOW.str值为"abcdef"，那么可以在方法调用处，通过调用strSubstring方法，根据给定的下标截取子字符串。同时，将截取结果缓存到任何字符型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351587.png)                                                                                                                                                                                                                                                          |
| strIndex0f()      | 获取第一次出现指定字符串的下标。 函数返回对象为下标值，整型。包含两个参数：第一个为待搜索的字符串，第二个为指定的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str值为"abcdef"，那么可以在方法调用处，通过调用strIndex0f方法，获取第一次出现指定字符串的下标。同时，将获取结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351597.png)                                                                                                                                                                                                                                                                                                |
| strStartsWith()   | 检测字符串是否以指定的前缀开始。 函数返回对象为检测结果，整型 0/1。包含两个参数：第一个为待检测的字符串，第二个为指定的前缀字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str值为"abcdef"，那么可以在方法调用处，通过调用strStartsWith方法，检测字符串是否以指定的前缀开始。同时，将检测结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391698.png)                                                                                                                                                                                                                                                                                        |
| strEndsWith()     | 检测字符串是否以指定的后缀结束。 函数返回对象为检测结果，整型 0/1。包含两个参数：第一个为待检测的字符串，第二个为指定的后缀字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str值为"abcdef"，那么可以在方法调用处，通过调用strEndsWith方法，检测字符串是否以指定的后缀结束。同时，将检测结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231772.png)                                                                                                                                                                                                                                                                                     |
| strParseJSON()    | 将json字符串转换为对象。 函数返回对象为转换之后的json对象，包含一个参数：待转换的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.strJson1值为Json格式的字符串 {"a":"1","b":"2"}，那么可以在方法调用处，通过调用strParseJSON方法，将字符串转成对象返回。同时，将结果缓存到任何对象类型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351623.png)                                                                                                                                                                                                                                                                                          |
| strParseInt()     | 将字符串转换为整型数字。 函数返回对象为转换之后的整型数字，包含一个参数：待转换的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str1值为 "11"，那么可以在方法调用处，通过调用strParseInt方法，将字符串转成整形数字返回。同时，将结果缓存到任何整型的变量(FLOW.int1)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231726.png)                                                                                                                                                                                                                                                                                                                           |
| strParseLong()    | 将字符串转换为长整型数字。 函数返回对象为转换之后的长整型数字，包含一个参数：待转换的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str1值为 "11"，那么可以在方法调用处，通过调用strParseLong方法，将字符串转成长整形数字返回。同时，将结果缓存到任何长整型的变量(FLOW.long1)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431607.png)                                                                                                                                                                                                                                                                                                             |
| strParseFloat()   | 将字符串转换为浮点型数字。 函数返回对象为转换之后的浮点型数字，包含一个参数：待转换的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str1值为 "0.56"，那么可以在方法调用处，通过调用strParseFloat方法，将字符串转成浮点型返回。同时，将结果缓存到任何浮点型的变量(FLOW.float1)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431581.png)                                                                                                                                                                                                                                                                                                                 |
| strLength()       | 获取字符串长度。 函数返回对象为字符串的长度，整型。包含一个参数：待计算长度的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str1值为"qwer"，那么可以在方法调用处，通过调用strLength方法，检测字符串的长度。同时，将结果缓存到任何整型的变量(FLOW.int1)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231768.png)                                                                                                                                                                                                                                                                                                                              |
| strToUpperCase()  | 将字符串小写字符转换为大写。 函数返回对象为转换之后的字符串，包含一个参数：待转换的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str1值为"qwer"，那么可以在方法调用处，通过调用strToUpperCase方法，将字符串的所有字符转换为大写。同时，将结果缓存到任何整型的变量(FLOW.str1)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351607.png)                                                                                                                                                                                                                                                                                                                  |
| strToLowerCase()  | 将字符串大写字符转换为小写。 函数返回对象为转换之后的字符串，包含一个参数：待转换的字符串。 使用场景示例： 例如有一个字符型的流程变量FLOW.str1值为"QWER"，那么可以在方法调用处，通过调用strToLowerCase方法，将字符串的所以字符转换为小写。同时，将结果缓存到任何整型的变量(FLOW.str1)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431573.png)                                                                                                                                                                                                                                                                                                                   |
| roman2dec()       | 将罗马数字转换成阿拉伯数字。 使用场景示例：例如有一个字符型的流程变量FLOW.Roman为罗马数字，如XII，那么可以在方法调用调用roman2dec函数生成阿拉伯数字的字符串"12" ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391700.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| numSpaceRemover() | 去除字符串中数字中间空格。 使用场景示例：例如有一个字符型的流程变量FLOW.test3为字母数字字符串，如"101 43 veinti"，那么可以在方法调用numSpaceRemover函数去除掉该字符串中数字中间的空格，去除结果为"10143 veinti" ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431563.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| replaceAll()      | 字符串替换 使用场景示例：例如有一个字符型的流程变量FLOW.var为普通字符串，如"123test"，那么可以在方法调用调用replaceAll函数去替换该字符串中指定的子字符串，如替换其中"123"为"\*\*\*"，替换结果为"\*\*\*test"，其中第一个参数为需要替换其中字符串的文本，第二个参数为需要替换的子字符串，第三个参数为用于替换的字符串文本。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351617.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| containSubstring  | 判断字符串中是否包含数组中的任意一个子字符串 使用场景示例：第一个参数为一个字符串，第二个参数为一个字符串数组，第三个参数为是否区分大小写0：不区分；1：区分；默认值 0。根据第三个参数是否区分大小写，判断第二个参数中的数组是否包含第一个参数中的字符串 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002625343886.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
   
表3数组操作方法 
| 函数名                 | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|
| arrayAdd()          | 向数组中添加一个元素。 方法返回值为添加是否成功的标识，如果添加成功返回1，否则返回0。 方法包含三个参数：第一个为待添加的数组，第二个为添加的位置（不填则默认尾部），第三个为添加的元素；该函数将修改待添加的数组。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[1,2,3,4\]，那么可以在方法调用处，通过调用arrayAdd方法，为FLOW.array添加元素，第二个参数可以指定添加的位置(索引)。同时，将添加结果缓存到任何整型的变量(FLOW.result)，添加成功后将修改FLOW.array变量的值并存入缓存中，此时FLOW.array的值为\[1,2,3,4,5\]，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231754.png) 如果不需要缓存添加是否成功的标识，只需要给数组尾部添加数据，则可以不填写方法返回值，第一个方法参数为待添加的数组FLOW.list，第二个方法参数不填写，第三个方法参数为添加的元素，此处使用的IVRREQUEST.input为用户的输入，如下图所示。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391696.png) |
| arrayAddAll()       | 向数组中添加另一个集合的所有元素。 函数返回对象为添加的结果，如果添加成功返回1，否则返回0。包含三个参数：第一个为待添加的数组，第二个为添加的位置（默认尾部），第三个为添加的元素；该函数将修改待添加的数组。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[1,2,3,4\]和FLOW.array2值为\[5,6,7,8\]，那么可以在方法调用处，通过调用arrayAddAll方法，为FLOW.array添加另一个集合中的元素，第二个参数可以指定添加的位置(索引)。同时，将添加结果缓存到任何整型的变量(FLOW.result)，添加成功后将修改FLOW.array变量的值并存入缓存中，此时FLOW.array的值为\[1,2,3,4,5,6,7,8\]，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431553.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| arrayContains()     | 判断元素是否在数组中。 函数返回对象为判断的结果，如果包含结果返回1，否则返回0。包含两个参数：第一个为待检测的数组，第二个为待判断的元素。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d\]，那么可以在方法调用处，通过调用arrayContains方法，判断所给定的元素是否包含在FLOW.array变量中。同时，将返回结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231752.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| arrayGet()          | 通过索引值获取数组中的元素。 函数返回对象为数组的元素，包含两个参数：第一个为待使用的数组，第二个为数组下标。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d\]，那么可以在方法调用处，通过调用arrayGet方法，从FLOW.array变量获取给定下标的值。同时，将返回结果缓存到给定的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431605.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| arrayRemoveIdx()    | 删除数组中的指定下标元素。 函数返回对象为删除的结果，如果删除成功返回1，否则返回0。包含两个参数：第一个为待使用的数组，第二个为删除数组下标。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d\]，那么可以在方法调用处，通过调用arrayRemoveIdx方法，删除FLOW.array变量指定下标的元素。同时，将删除结果缓存到任何整型的变量(FLOW.result)，删除成功后将修改FLOW.array变量的值并存入缓存中，此时FLOW.array的值为\[a,b,d\]，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231774.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| arrayRemoveAllIdx() | 删除数组中指定下标集合对应的元素。 函数返回对象为删除的结果，如果删除成功返回1，否则返回0。包含两个参数：第一个为待使用的数组，第二个为指定集合。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d,e,f\]和FLOW.indexArray值为\[2,3,4\]，那么可以在方法调用处，通过调用arrayRemoveAllIdx方法，为FLOW.array删除存在另一个集合中的索引对应的值，第二个参数可以指定删除的索引集合。同时，将删除结果缓存到任何整型的变量(FLOW.result)，删除成功后将修改FLOW.array变量的值并存入缓存中，此时FLOW.array的值为\[a,b,f\]，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231746.png) 说明： FLOW.indexArray为第一个列表型变量FLOW.array的索引集合，只支持非负整数，且集合中的值不得超过FLOW.array的最大索引值。                                                                                                                                                                                                                                       |
| arrayClear()        | 删除数组中的所有元素。 函数返回对象为void，输入框灰化不可编辑。包含一个参数：待清理的数组。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d\]，那么可以在方法调用处，通过调用arrayClear方法，为FLOW.array删除数组中的所有元素。同时，调用方法后将修改FLOW.array变量的值并存入缓存中，此时FLOW.array的值为\[\]，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351621.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| arraySize()         | 获取数组的长度。 函数返回对象为数组长度，整型。包含一个参数：为待计算长度的数组。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d,e,f\]，那么可以在方法调用处，通过调用arraySize方法，获取FLOW.array数组的长度。同时，将获取结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231778.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| arraySubList()      | 截取并返回数组中的一部分。 函数返回对象为子数组，包含三个参数：第一个为待截取的数组，第二个为截取起始位置，第三个为截取结束位置。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d,e,f\]，那么可以在方法调用处，通过调用arraySubList方法，截取FLOW.array数组中的一部分。同时，将截取结果缓存到任何列表型的变量(FLOW.subArray)，截取到的值FLOW.subArray为\[c,d,e\]，截取的区间为左闭右合区间。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431585.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| arrayJoin()         | 将数组转成字符串。 函数返回对象为转换后的字符串。包含两个参数：第一个为待转换的数组，第二个为连接字符串。 使用场景示例： 例如有一个列表型的流程变量FLOW.array值为\[a,b,c,d\]，那么可以在方法调用处，通过调用arrayJoin方法，将数组中的元素通过给定的符号转成字符串。同时，将转换结果缓存到任何字符型的变量(FLOW.result)，下方示例处返回结果值为a=b=c=d。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351629.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
   
表4增加对Map的操作方法 
| 函数名         | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|:---|:---|
| mapPut()    | 向map中添加一个元素。 函数返回对象逻辑为如果key不存在，则返回null，如果存在则返回原先被替换的value值，对象类型。函数包含三个参数：第一个为待添加的map，第二个为key（仅支持字符串类型），第三个为添加的元素。 使用场景示例： 例如有一个对象型的流程变量FLOW.person值为{"name":"Jack","sex":"boy"}，那么可以在方法调用处，通过调用mapPut方法，为FLOW.person添加元素值。同时，将添加结果缓存到变量(FLOW.result)，添加成功后将修改FLOW.person变量的值并存入缓存中，此时FLOW.person的值为{"name":"Jack","sex":"boy","age":"25"}，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391680.png) 说明： 对于手动赋值的一个对象型的变量，输入框参数值处不能使用双引号，通过参数支持的流程变量则不同，可参照上方用例 如果要向对象型变量中添加一个列表数据，则第三个参数只能使用预先定义好的变量，不可使用输入框直接输入数组，输入框输入默认为字符串类型。 |
| mapGet()    | 获取map中指定键映射的值。 函数返回对象为指定键映射的值。函数包含两个参数：第一个为待处理的map，第二个为key（仅支持字符串类型）。 使用场景示例： 例如有一个对象型的流程变量FLOW.person值为{"name":"Jack","sex":"boy"}，那么可以在方法调用处，通过调用mapGet方法，获取map中指定键映射的值。同时，将获取结果缓存到变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351649.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| mapRemove() | 删除map中指定键值对。 函数返回对象为此映射先前与该键关联的值；如果该映射不包含该键的映射,则返回null。包含两个参数：第一个为待处理的map，第二个为key（仅支持字符串类型）。 使用场景示例： 例如有一个对象型的流程变量FLOW.person值为{"name":"Jack","sex":"boy"}，那么可以在方法调用处，通过调用mapRemove方法，删除map中指定键值对。同时，将删除结果缓存到变量(FLOW.result)，删除后将修改FLOW.person变量的值并存入缓存中，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391690.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| mapClear()  | 清空map的所有键值对。 函数返回对象为void，输入框灰化不可编辑。包含一个参数：待清理的map。 使用场景示例： 例如有一个对象型的流程变量FLOW.person值为{"name":"Jack","sex":"boy"}，那么可以在方法调用处，通过调用mapClear方法，清空map的所有键值对。同时，调用方法后将修改FLOW.person变量的值并存入缓存中，直到该流程结束或者再一次修改它的值。该方法调用的参数支持变量赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431583.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| mapSize()   | 获取map的所有key的数量。 函数返回对象为map中key的数量，整型。包含一个参数：为待计算数量的map。 使用场景示例： 例如有一个对象型的流程变量FLOW.person值为{"name":"Jack","sex":"boy"}，那么可以在方法调用处，通过调用mapSize方法，获取map的所有key的数量。同时，调用方法后将获取结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557351643.png)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
   
表5增加对日期处理的操作方法 
| 函数名                     | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|
| offsetMonth()           | 按月偏移。 返回对象为字符串类型，保存偏移后的数据。 方法包含两个参数：第一个为待偏移的时间变量，字符串类型，格式为yyyyMM，如：202308，第二个为偏移数，整型，可以为负值，例如-6代表将源字符串向前推移6个月。 使用场景示例： 例如有一个字符串的流程变量FLOW.date值为"202308"，那么可以在方法调用处，通过调用offsetMonth方法，获取偏移后的日期。同时，调用方法后将获取结果缓存到任何整型的变量(FLOW.result)。该方法调用的参数支持变量赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231756.png)                                                                                                                                                                                                                                                                                                                                                          |
| offsetHour()            | 按小时偏移。 返回对象为字符串类型，保存偏移后的数据。 方法包含两个参数：第一个为待偏移的时间变量，字符串类型，格式为yyyyMMddHHmmss，如：20230808122020，第二个为偏移数，整型，可以为负值，例如-6代表将源字符串向前推移6个小时。 使用场景示例： 例如有一个字符串型的流程变量FLOW.date值为"20230831165801"，那么可以在方法调用处，通过调用offsetHour方法，获取偏移后的小时。同时，将获取结果缓存到变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391720.png)                                                                                                                                                                                                                                                                                                                                    |
| offsetMinute()          | 按分钟偏移。 返回对象为字符串类型，保存偏移后的数据。 方法包含两个参数：第一个为待偏移的时间变量，字符串类型，格式为yyyyMMddHHmmss，如：20230808122020，第二个为偏移数，整型，可以为负值，例如-6代表将源字符串向前推移6分钟。 使用场景示例： 例如有一个字符串型的流程变量FLOW.date值为"20230831165801"，那么可以在方法调用处，通过调用offsetMinute方法，获取偏移后的分钟。同时，将获取结果缓存到变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431595.png)                                                                                                                                                                                                                                                                                                                                     |
| offsetSecond()          | 按秒偏移。 返回对象为字符串类型，保存偏移后的数据。 方法包含两个参数：第一个为待偏移的时间变量，字符串类型，格式为yyyyMMddHHmmss，如：20230808122020，第二个为偏移数，整型，可以为负值，例如-6代表将源字符串向前推移6秒。 使用场景示例： 例如有一个字符串型的流程变量FLOW.date值为"20230831165801"，那么可以在方法调用处，通过调用offsetSecond方法，获取偏移后的秒。同时，将获取结果缓存到变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391722.png)                                                                                                                                                                                                                                                                                                                                      |
| cacHourDifference()     | 时间间隔计算。 返回对象为字符串类型，保存与传入参数比较对应的时间差。 方法包括一个参数：时间变量，字符串类型，格式为HHmm，如：1900。 使用场景示例： 参数为1900，即19点整，转换后的当前时间为14:00，则计算结果为300分钟，结果为300； 参数为1900，即19点整，转换后的当前时间为23:00，则计算结果为-240分钟，结果为-240； 参数为1900，即19点整，转换后的当前时间为02:00，则计算结果为900分钟，结果为900； 将获取结果缓存到变量(FLOW.result)。该方法调用的参数支持变量赋值和手动赋值。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391670.png) |
| entityTimeToTimestamp() | 时间实体转时间戳计算。 返回对象为字符串类型，将TUC时间识别接口返回的时间实体对象entityMsgV2List时间转换为秒级时间戳。 该方法与tuc时间识别接口一起使用，方法包括一个参数，为TUC时间识别接口返回的 entityMsgV2List。 使用场景示例： ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526231734.png) ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002526391714.png)                                                                                                                                                                                                                                                                                                                                                                          |
   
表6数字操作方法 
| 函数名         | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|
| randPercent | 百分比随机函数。 例如有一个字符变量为FLOW.allocation,分支图元的三个分支条件为小于20%、小于50%大于等于20%、大于等于50%，那么可以在方法调用处，调用randPercent函数生成不同的随机数，从而走到不同的分支进行处理。 图1百分比函数 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002563319035.png) 图2方法调用 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431609.png) |
| add         | 加法。 方法包含两个参数：第一个为被加数，支持整型或长整型，如：123456，第二个为加数，支持整型或长整型。 返回结果为长整型。 ![](https://support.huaweicloud.com/usermanual-cec/figure/zh-cn_image_0000002557431601.png)                                                                  |
   
