你当前正在访问 Microsoft Azure Global Edition 技术文档网站。如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

自适应表达式预生成函数

项目
12/26/2023

适用于： SDK v4

本文列出了按常规用途排序的可用预生成函数。有关预生成函数和表达式语法中使用的运算符的信息，请参阅运算符。

预生成的表达式分为以下函数类型：

字符串
集合
逻辑比较
转换
数学
日期
Timex
URI 分析
对象操作和构造
正则表达式
类型检查

也可以按字母顺序查看该列表。

字符串函数

函数	解释
length	返回字符串的长度。
replace	将 substring 替换为指定的字符串，并返回更新后的字符串。此函数区分大小写。
replaceIgnoreCase	将子字符串替换为指定的字符串，并返回更新的字符串。此函数区分大小写。
split	返回一个数组，该数组包含基于指定分隔符的 substring。
substring	返回字符串中的字符。
toLower	以可选区域设置格式返回小写字符串。
toUpper	以可选区域设置格式返回大写字符串。
trim	从字符串中删除前导空格和尾随空格。
addOrdinal	返回输入数字的序数。
endsWith	检查字符串是否以特定的子字符串结尾。如果找到 substring，返回 `true`；否则返回 `false`。此函数区分大小写。
startsWith	检查字符串是否以特定的子字符串开头。如果找到 substring，返回 `true`；否则返回 `false`。此函数区分大小写。
countWord	返回给定字符串中的单词数。
concat	合并两个或更多字符串，并返回生成的字符串。
newGuid	返回新的 Guid 字符串。
indexOf	返回 substring 的起始位置或索引值，或者搜索指定的对象，然后返回整个列表中第一次出现的从零开始的索引。此函数区分大小写，并且索引从数字 0 开始。
lastIndexOf	返回最后一次出现的 substring 的起始位置或索引值，或者搜索指定的对象，并返回列表中元素范围内最后一次出现的从零开始的索引。此函数区分大小写，并且索引从数字 0 开始。
sentenceCase	以可选的区域设置格式将字符串中的第一个词的第一个字母大写。
titleCase	以可选的区域设置格式将字符串中的每个词的第一个字母大写。
reverse	反转字符串或数组中元素的顺序。

集合函数

函数	说明
contains	用于在字符串中查找项、在数组中查找项或在复杂对象中查找参数。示例： contains('hello world', 'hello') contains(createArray('1','2'), '1') contains(json("{'foo':'bar'}"), 'foo')
first	返回集合中的第一项。
join	返回一个字符串，它包含某个数组中的所有项并且以分隔符分隔每个字符。示例： join(createArray('a','b'), '.') = “a.b”
last	返回集合中的最后一项。
count	返回集合中的项数。
foreach	对每个元素执行操作并返回新集合。
union	返回一个集合，其中包含指定集合中的所有项。
skip	删除集合开头的项，并返回其余项。
take	返回集合开头的项。
intersection	返回其中仅包含指定集合的共有项的一个集合。
subArray	从指定起始位置和结束位置返回子数组。索引值从数字 0 开始。
select	对每个元素执行操作并返回转换后的元素的新集合。
where	对每个元素进行筛选，然后返回与特定条件匹配的筛选后的新元素集合。
sortBy	按升序对集合中的元素进行排序，然后返回排序后的集合。
sortByDescending	按降序对集合中的元素进行排序，然后返回排序后的集合。
indicesAndValues	将一个数组或对象变成具有索引和值属性的多个对象的数组。
flatten	将数组平展为具有非数组值的数组。
unique	从数组中删除所有重复项。
任意	确定序列中是否有元素满足条件。
全部	确定序列中的所有元素是否都满足条件。
reverse	反转字符串或数组中元素的顺序。
merge	将数组中的多个 JSON 对象或项合并在一起。

逻辑比较函数

函数	说明
和	逻辑与。如果所有指定的表达式求值为 true，则返回 true。
equals	比较相等。如果指定的值相等，则返回 true。
empty	检查目标是否为空。
greater	比较大于。如果第一个值更大，则返回 `true`；否则返回 `false`。
greaterOrEquals	比较大于或等于。如果第一个值大于或等于第二个值，则返回 `true`；否则返回 `false`。
if	检查表达式为 true 还是 false。根据结果返回指定的值。
less	比较小于运算。如果第一个值更小，则返回 `true`；否则返回 `false`。
lessOrEquals	比较小于或等于运算。如果第一个值小于或等于第二个值，则返回 `true`；否则返回 `false`。
not	逻辑 not 运算符。如果表达式为 false，则返回 `true`；如果表达式为 true，则返回 `false`。
或	逻辑或运算符。如果至少一个表达式为 true，则返回 `true`；如果所有表达式均为 false，则返回 `false`。
exists	计算表达式的真假性。

转换函数

函数	说明
float	返回指定字符串的浮点表示。
int	返回指定字符串的整数表示。
字符串	以可选区域设置格式返回指定值的字符串版本。
bool	返回指定字符串的布尔值表示形式。
createArray	从多个输入创建数组。
json	返回字符串或 XML 的 JavaScript 对象表示法 (JSON) 类型的值或对象。
base64	返回字符串或字节数组的 base64 编码版本。
base64ToBinary	返回 base64 编码字符串的二进制版本。
base64ToString	返回 base64 编码字符串的字符串版本。
binary	返回输入值的二进制版本。
dataUri	返回输入值的 URI。
dataUriToBinary	返回数据 URI 的二进制版本。
dataUriToString	返回数据 URI 的字符串版本。
uriComponent	通过将 URL 不安全字符替换为转义字符来返回输入值的 URI 编码版本。
uriComponentToString	返回 URI 编码字符串的字符串版本。
xml	返回字符串的 XML 版本。
formatNumber	将值格式化为最接近的数字，以指定的小数位数和可选的指定区域设置。
jsonStringify	返回值的 JSON 字符串版本。
stringOrValue Wrap 字符串内插以获取实际值。例如， `stringOrValue('${1}')` 返回数字 1，同时 `stringOrValue('${1} item')` 返回字符串“1 项”。

数学函数

函数	说明
abs	返回指定数字的绝对值。
add	数学加法。返回将两个数字相加（纯数字情况）或将两个或更多个字符串连接后获得的结果。
div	数学除法。返回将两个数字相除后的整数结果。
max	返回集合中的最大值。
min	返回集合中的最小值。
mod	返回将两个数字相除后的余数。
mul	数学乘法。返回将两个数字相乘得到的乘积。
rand	返回指定最小值和最大值之间的随机数。
sqrt	返回指定数字的平方根。
sub	数学减法。返回第一个数字减去第二个数字得到的结果。
sum	返回数组中的数字之和。
range	返回以指定整数开头的一个整数数组。
exp	返回 n 的 m 次幂。
average	返回数值阵列的平均数。
floor	返回小于或等于指定数字的最大整数值。
ceiling	返回大于或等于指定数字的最小整数值。
round	将值舍入到最接近的整数或指定的小数位数。

日期和时间函数

函数	解释
addDays	以可选的区域设置格式将指定的天数添加到给定的时间戳中。
addHours	以可选的区域设置格式将指定的小时数添加到给定的时间戳中。
addMinutes	以可选的区域设置格式将指定的分钟数添加到给定的时间戳中。
addSeconds	将指定的秒数添加到给定的时间戳中。
dayOfMonth	返回给定时间戳或 Timex 表达式的月份中的某天。
dayOfWeek	返回给定时间戳的一周中的一天。
dayOfYear	返回给定时间戳的一年中的一天。
formatDateTime	以可选区域设置格式返回时间戳。
formatEpoch	以可选的区域设置格式返回 UNIX Epoch 时间（Unix 时间、POSIX 时间）的时间戳。
formatTicks	从刻度返回采用可选区域设置格式的时间戳。
subtractFromTime	以可选的区域设置格式从时间戳中减去一定数目的时间单位。
utcNow	以可选的区域设置格式返回字符串形式的时间戳。
dateReadBack	使用日期时间库提供日期回读。
month	返回给定时间戳的月份。
date	返回给定时间戳的日期。
year	返回给定时间戳的年份。
getTimeOfDay	返回给定时间戳的一天中的某个时间。
getFutureTime	以可选的区域设置格式返回当前时间戳加上指定的时间单位。
getPastTime	以可选的区域设置格式返回当前时间戳减去指定的时间单位。
addToTime	以可选的区域设置格式将多个时间单位添加到时间戳中。
convertFromUTC	从协调世界时（UTC）转换采用可选区域设置格式的时间戳。
convertToUTC	将采用可选区域设置格式的时间戳转换为协调世界时（UTC）。
startOfDay	以可选区域设置格式返回时间戳的开始日期。
startOfHour	以可选区域设置格式返回时间戳的开始小时。
startOfMonth	以可选区域设置格式返回时间戳中的开始月份。
ticks	返回指定时间戳的时钟周期属性值。
ticksToDays	将刻度属性值转换为天数。
ticksToHours	将刻度属性值转换为小时数。
ticksToMinutes	将刻度属性值转换为分钟数。
DateTimeDiff	以时间跨度形式返回两个时间戳之间的差值。
getPreviousViableDate	根据当前日期和可选的指定时区返回 Timex 表达式的上一个可行日期。
getNextViableDate	根据当前日期和可选的指定时区返回 Timex 表达式的下一个可行日期。
getPreviousViableTime	根据当前时间和可选的指定时区返回 Timex 表达式的上一个可行时间。
getNextViableTime	根据当前时间和可选的指定时区返回 Timex 表达式的下一个可行时间。

Timex 函数

函数	说明
isPresent	如果 TimexProperty 或 Timex 表达式引用当前时间，则返回 true。
isDuration	如果 TimexProperty 或 Timex 表达式引用持续时间，则返回 true。
isTime	如果 TimexProperty 或 Timex 表达式引用时间，则返回 true。
isDate	如果 TimexProperty 或 Timex 表达式引用日期，则返回 true。
isTimeRange	如果 TimexProperty 或 Timex 表达式引用时间范围，则返回 true。
isDateRange	如果 TimexProperty 或 Timex 表达式引用日期范围，则返回 true。
isDefinite	如果 TimexProperty 或 Timex 表达式引用准确日期，则返回 true。
resolve	如果给定 TimexProperty 或 Timex 表达式引用有效时间，则返回一个字符串。有效时间包含小时数、分钟数和秒数。

URI 分析函数

函数	解释
uriHost	返回统一资源标识符 (URI) 的主机值。
uriPath	返回统一资源标识符 (URI) 的路径值。
uriPathAndQuery	返回统一资源标识符 (URI) 的路径和查询值。
uriPort	返回统一资源标识符 (URI) 的端口值。
uriQuery	返回统一资源标识符 (URI) 的查询值。
uriScheme	返回统一资源标识符 (URI) 的方案值。

对象操作和构造函数

函数	说明
addProperty	将属性及其值或名称/值对添加到 JSON 对象，并返回更新后的对象。
removeProperty	从 JSON 对象中删除某个属性，并返回更新后的对象。
setProperty	设置 JSON 对象的属性值并返回更新后的对象。
getProperty	从 JSON 对象返回指定属性或根属性的值。
coalesce	返回一个或多个参数中的第一个非 null 值。
xPath	检查 XML 中是否存在与 XPath（XML 路径语言）表达式匹配的节点或值，并返回匹配的节点或值。
jPath	检查 JSON 或 JSON 字符串中与路径表达式匹配的节点或值，然后返回匹配的节点。
setPathToValue	设置特定路径的值并返回该值。

正则表达式函数

函数	解释
isMatch	如果字符串与常见的正则表达式模式匹配，则返回 true。

类型检查函数

函数	解释
EOL	返回行尾（EOL）序列的文本。
isInteger	如果给定输入为整数，则返回 true
isFloat	如果给定输入为浮点数，则返回 true
isBoolean	如果给定输入为布尔值，则返回 true。
isArray	如果给定输入为数组，则返回 true。
isObject	如果给定输入为对象，则返回 true。
isDateTime	如果给定输入是 UTC ISO 格式的时间戳，则返回 true。
isString	如果给定输入为字符串，则返回 true。

按字母顺序排序的预生成函数

abs

返回指定数字的绝对值。

abs(<number>)

参数	必选	类型	说明
<number>	是	数字	要获取绝对值的数字

返回值	类型	说明
<result>	数字	计算绝对值的结果。

示例

这些示例计算绝对值：

abs(3.12134)
abs(-3.12134)

两者都返回结果 3.12134。

add

返回将两个或更多个数字相加（纯数字情况）或将两个或更多个字符串连接（其他情况）后获得的结果。

add(<item1>, <item2>, ...)

参数	必选	类型	描述
<item1>, <item2>,...	是	any	items

返回值	类型	说明
<result-sum>	数字或字符串	将指定数字相加后获得的结果或连接结果。

示例

此示例将指定的数字相加：

add(1, 1.5)

并返回结果 2.5。

此示例连接指定项：

add('hello',null)
add('hello','world')

然后返回结果

hello
helloworld

addDays

以可选区域设置格式将天数添加到时间戳。

addDays('<timestamp>', <days>, '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串必须为标准 UTC ISO 格式 YYYY-MM-DDTHH:mm:ss.fffZ
<days>	是	integer	要加上的正负天数
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<updated-timestamp>	string	时间戳加上指定的天数

示例 1

此示例将 10 天加到指定的时间戳：

addDays('2018-03-15T13:00:00.000Z', 10)

并返回结果 2018-03-25T00:00:00.000Z。

示例 2

此示例从指定的时间戳减去 5 天：

addDays('2018-03-15T00:00:00.000Z', -5)

并返回结果 2018-03-10T00:00:00.000Z。

示例 3

此示例将 1 天添加到 de-DE 区域设置中的指定时间戳：

addDays('2018-03-15T13:00:00.000Z', 1, '', 'de-dE')

并返回结果 16.03.18 13:00:00。

addHours

以可选区域设置格式将小时数添加到时间戳。

addHours('<timestamp>', <hours>, '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<hours>	是	integer	要加上的正负小时数
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<updated-timestamp>	string	时间戳加上指定的小时数

示例 1

此示例将 10 小时加到指定的时间戳：

addHours('2018-03-15T00:00:00.000Z', 10)

并返回结果 2018-03-15T10:00:00.000Z。

示例 2

此示例从指定的时间戳减去 5 小时：

addHours('2018-03-15T15:00:00.000Z', -5)

并返回结果 2018-03-15T10:00:00.000Z。

示例 3

此示例在 de-DE 区域设置中将 2 小时添加到指定的时间戳：

addHours('2018-03-15T13:00:00.000Z', 2, '', 'de-DE')

并返回结果 15.03.18 15:00:00。

addMinutes

以可选区域设置格式向时间戳添加分钟数。

addMinutes('<timestamp>', <minutes>, '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<minutes>	是	integer	要加上的正负分钟数
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<updated-timestamp>	string	时间戳加上指定的分钟数

示例 1

此示例将 10 分钟加到指定的时间戳：

addMinutes('2018-03-15T00:10:00.000Z', 10)

并返回结果 2018-03-15T00:20:00.000Z。

示例 2

此示例从指定的时间戳减去 5 分钟：

addMinutes('2018-03-15T00:20:00.000Z', -5)

并返回结果 2018-03-15T00:15:00.000Z。

示例 3

该示例在 de-DE 区域设置中将 30 分钟添加到指定的时间戳：

addMinutes('2018-03-15T00:00:00.000Z', 30, '', 'de-DE')

并返回结果 15.03.18 13:30:00。

addOrdinal

返回输入数字的序数。

addOrdinal(<number>)

参数	必选	类型	说明
<number>	是	integer	要转换为序数的数字

返回值	类型	说明
<result>	string	转换自输入数字的序数

示例

addOrdinal(11)
addOrdinal(12)
addOrdinal(13)
addOrdinal(21)
addOrdinal(22)
addOrdinal(23)

并分别返回以下结果：

第 11
第 12
第 13
第 21
第 22
第 23

addProperty

将属性及其值或名称/值对添加到 JSON 对象，并返回更新的对象。如果在运行时已存在该对象，此函数将引发错误。

addProperty('<object>', '<property>', value)

参数	必选	类型	说明
<object>	是	对象 (object)	要将属性添加到的 JSON 对象
<property>	是	string	要添加的属性的名称
<value>	是	any	属性的值

返回值	类型	说明
<updated-object>	object	添加新属性后更新的 JSON 对象

示例

此示例将 accountNumber 属性添加到 customerProfile 对象，该对象通过 json() 函数转换为 JSON。此函数分配由 newGuid() 函数生成的值，并返回更新后的对象：

addProperty(json('customerProfile'), 'accountNumber', newGuid())

addSeconds

将秒数加到时间戳。

addSeconds('<timestamp>', <seconds>, '<format>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<seconds>	是	integer	要加上的正负秒数
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。

返回值	类型	说明
<updated-timestamp>	string	时间戳加上指定的秒数

示例 1

此示例将 10 秒加到指定的时间戳：

addSeconds('2018-03-15T00:00:00.000Z', 10)

并返回结果 2018-03-15T00:00:10.000Z。

示例 2

此示例从指定的时间戳减去 5 秒：

addSeconds('2018-03-15T00:00:30.000Z', -5)

并返回结果 2018-03-15T00:00:25.000Z。

addToTime

以可选区域设置格式将多个时间单位添加到时间戳中。另请参阅 getFutureTime()。

addToTime('<timestamp>', '<interval>', <timeUnit>, '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<间隔>	是	integer	要添加的指定时间单位数
<timeUnit>	是	string	间隔使用的时间单位。可能的单位为“秒”、“分钟”、“小时”、“天”、“周”、“月”。
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<updated-timestamp>	string	时间戳加上给定格式的指定时间单位的数量。

示例 1

此示例将 1 天添加到指定的时间戳。

addToTime('2018-01-01T00:00:00.000Z', 1, 'Day')

并返回结果 2018-01-02T00:00:00.000Z。

示例 2

此示例将两周添加到指定的时间戳。

addToTime('2018-01-01T00:00:00.000Z', 2, 'Week', 'MM-DD-YY')

并以“MM-YY”格式返回结果，即为 01-15-18。

全部

确定序列中的所有元素是否都满足条件。

all(<sequence>, <item>, <condition>)

参数	必选	类型	描述
<序列>	是	对象 (object)	要计算的序列。
<item>	是	string	指要在序列中计算的元素。
<条件>	是	表达式	要计算的条件表达式。

返回值	类型	说明
true 或 false	布尔	若所有元素都满足条件，则返回 `true`。若至少有一个没有，则返回 `false`。

示例

这些示例确认序列中的所有元素是否都满足条件：

all(createArray(1, 'cool'), item, isInteger(item))
all(createArray(1, 2), item => isInteger(item))

并分别返回下列结果：

false，因为序列中的两个项不是整数。
true，因为序列中的两个项都是整数。

和

检查所有表达式是否为 true。如果所有表达式均为 true，返回 true；如果至少一个表达式为 false，则返回 false。

and(<expression1>, <expression2>, ...)

参数	必选	类型	说明
<expression1>、<expression2>，...	是	Boolean	要检查的表达式

返回值	类型	说明
true 或 false	布尔	如果所有表达式均为 true，返回 `true`。如果至少一个表达式为 false，返回 `false`。

示例 1

这些示例检查指定的布尔值是否全为 true：

and(true, true)
and(false, true)
and(false, false)

并分别返回以下结果：

两个表达式均为 true，所以此函数返回 true。
一个表达式为 false，所以此函数返回 false。
两个表达式均为 false，所以此函数返回 false。

示例 2

这些示例检查指定的表达式是否均为 true：

and(equals(1, 1), equals(2, 2))
and(equals(1, 1), equals(1, 2))
and(equals(1, 2), equals(1, 3))

并分别返回以下结果：

两个表达式均为 true，所以此函数返回 true。
一个表达式为 false，所以此函数返回 false。
两个表达式均为 false，所以此函数返回 false。

any

确定序列中是否有元素满足条件。

all(<sequence>, <item>, <condition>)

参数	必选	类型	描述
<序列>	是	对象 (object)	要计算的序列。
<item>	是	string	指要在序列中计算的元素。
<条件>	是	表达式	要计算的条件表达式。

返回值	类型	说明
true 或 false	布尔	若所有元素都满足条件，则返回 `true`。若至少有一个没有，则返回 `false`。

示例

这些示例确认序列中的所有元素是否都满足条件：

any(createArray(1, 'cool'), item, isInteger(item))
any(createArray('first', 'cool'), item => isInteger(item))

并分别返回下列结果：

true，因为序列中至少有一个项是整数
false，因为序列中的两个项都不是整数。

average

返回数值阵列的数均。

average(<numericArray>)

参数	必选	类型	描述
<numericArray>	是	数字数组	用于计算平均值的输入数组

返回值	类型	描述
<average-of-array>	数字	给定数组的平均值

示例

下面的示例计算 createArray() 中数组的平均值：

average(createArray(1,2,3))

并返回结果 2。

base64

返回字符串或字节数组的 base64 编码版本。

base64('<value>')

参数	必选	类型	说明
<value>	是	字符串或字节数组	输入字符串

返回值	类型	说明
<base64-string>	string	输入字符串的 base64 编码版本

示例 1

此示例将字符串“hello”转换为 base64 编码的字符串：

base64('hello')

并返回结果“aGVsbG8=”。

示例 2

此示例采用 byteArr等于 new byte[] { 3, 5, 1, 12 }：

base64('byteArr')

并返回结果“AwUBDA==”。

base64ToBinary

返回 base64 编码的字符串的二进制数组。

base64ToBinary('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的 base64 编码字符串

返回值	类型	说明
<binary-for-base64-string>	Byte Array	base64 编码字符串的二进制版本

示例

此示例将 base64 编码的字符串“AwUBDA==”转换为二进制字符串：

base64ToBinary('AwUBDA==')

并返回结果“new byte[] { 3, 5, 1, 12 }”。

base64ToString

返回 base64 编码字符串的字符串版本，有效地对 base64 字符串进行解码。

base64ToString('<value>')

参数	必选	类型	说明
<value>	是	string	要解码的 base64 编码字符串

返回值	类型	说明
<decoded-base64-string>	string	base64 编码的字符串的字符串版本

示例

此示例将 base64 编码的字符串“aGVsbG8=”转换为二进制字符串：

base64ToString('aGVsbG8=')

并返回结果“hello”。

binary

返回字符串的二进制版本。

binary('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的字符串

返回值	类型	说明
<binary-for-input-value>	Byte Array	指定字符串的二进制版本

示例

此示例将字符串“hello”转换为二进制字符串：

binary('hello')

并返回结果“new byte[] { 104, 101, 108, 108, 111 }”。

bool

返回值的布尔版本。

bool(<value>)

参数	必选	类型	说明
<value>	是	any	要转换的值

返回值	类型	说明
true 或 false	布尔	指定值的布尔版本

示例

这些示例将指定的值转换为布尔值：

bool(1)
bool(0)

并分别返回以下结果：

true
false

ceiling

返回小于或等于指定数字的最大整数值。

ceiling('<number>')

参数	必选	类型	说明
<number>	是	number	输入数字

返回值	类型	描述
<整数值>	integer	大于或等于输入数字的最大整数值

示例

该示例返回小于或等于数字 10.333 的最大整数值：

ceiling(10.333)

并返回整数 11。

coalesce

返回一个或多个参数中的第一个非 null 值。空字符串、空数组和空对象不为 null。

coalesce(<object**1>, <object**2>, ...)

参数	必选	类型	描述
<object1>>, <<object2>>, ...	是	任何（接受混合类型）	要检查是否为 null 的一个或多个项

返回值	类型	说明
<first-non-null-item>	any	第一个不为 NULL 的项或值。如果所有参数均为 null，则此函数返回 null。

示例

这些示例返回指定值中的第一个非 null 值，当所有值均为 null 时返回 null：

coalesce(null, true, false)
coalesce(null, 'hello', 'world')
coalesce(null, null, null)

分别返回：

true
hello
null

concat

组合两个或更多对象，并将组合的对象返回为列表或字符串。

concat('<text1>', '<text2>', ...)

参数	必选	类型	说明
<object1>, <object2>, ...	是	any	至少要连接两个对象。

返回值	类型	描述
<object1object2...>	字符串或列表	组合的字符串或列表。跳过 Null 值。

预期的返回值：

如果所有项都是列表，则返回一个列表。
如果存在不是列表的项，将返回一个字符串。
如果值为 null，则会跳过该值，且不会连接。

示例

此示例将字符串“Hello”和“World”组合到一起：

concat('Hello', 'World')

并返回结果“HelloWorld”。

示例 2

此示例合并列表 [1,2] 和 [3,4]：

concat([1,2],[3,4])

并返回结果 [1, 2, 3, 4]。

示例 3

这些示例合并不同类型的对象：

concat('a', 'b', 1, 2)
concat('a', [1,2])

并分别返回下列结果：

字符串 ab12。
对象 aSystem.Collections.Generic.List 1[System.Object]。这是不可读的，最好避免。

示例 4

这些示例组合对象将 null：

concat([1,2], null)
concat('a', 1, null)

并分别返回下列结果：

列表 [1,2]。
字符串 a1。

contains

检查集合是否包含某个特定项。如果找到该项，返回 true；否则返回 false。此函数区分大小写。

contains('<collection>', '<value>')
contains([<collection>], '<value>')

此函数适用于以下集合类型：

字符串，在其中查找子字符串
数组，在其中查找值
字典，在其中查找键

参数	必选	类型	说明
<collection>	是	字符串、数组或字典	要检查的集合
<value>	是	分别为字符串、数组或字典	要查找的项

返回值	类型	说明
true 或 false	布尔	如果找到该项，返回 `true`。如果未找到该项，则返回 `false`。

示例 1

此示例检查字符串“hello world”中是否有 substring“world”：

contains('hello world', 'world')

并返回结果 true。

示例 2

此示例检查字符串“hello world”中是否有 substring“universe”：

contains('hello world', 'universe')

并返回结果 false。

count

返回集合中的项数。

count('<collection>')
count([<collection>])

参数	必选	类型	说明
<collection>	是	字符串或数组	包含要计数的项的集合

返回值	类型	说明
<length-or-count>	integer	集合中的项数

示例：

这些示例对以下集合中的项数进行计数：

count('abcd')
count(createArray(0, 1, 2, 3))

两者都返回结果 4。

countWord

返回字符串中的单词数

countWord('<text>')

参数	必选	类型	说明
<text>	是	string	要计数的字符串

返回值	类型	说明
<count>	integer	字符串中的单词数

示例

此示例计算字符串“hello world”中的单词数：

countWord("hello word")

它返回结果 2。

convertFromUTC

以可选的区域设置格式将时间戳从协调世界时 (UTC) 转换为目标时区。

convertFromUTC('<timestamp>', '<destinationTimeZone>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<destinationTimeZone>	是	string	目标时区的名称。支持 Windows 时区和 Iana 时区。
<format>	否	string	自定义格式模式。时间戳的默认格式为 “o” 格式，即 yyyy-MM-ddTHH:mm:ss.fffffffK，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<converted-timestamp>	string	已转换为目标时区的时间戳

示例：

这些示例将 UTC 转换为太平洋标准时间：

convertFromUTC('2018-02-02T02:00:00.000Z', 'Pacific Standard Time', 'MM-DD-YY')
convertFromUTC('2018-02-02T02:00:00.000Z', 'Pacific Standard Time')

并分别返回以下结果：

02-01-18
2018-01-01T18:00:00.0000000

示例 2

此示例将 en-US 区域设置中的时间戳从 UTC 转换为太平洋标准时间：

convertFromUTC('2018-01-02T02:00:00.000Z', 'Pacific Standard Time', 'D', 'en-US')

并返回结果 星期一，2018 年 1 月 1 日。

convertToUTC

以可选的区域设置格式将时间戳从源时区转换为协调世界时 (UTC)。

convertToUTC('<timestamp>', '<sourceTimeZone>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<sourceTimeZone>	是	string	目标时区的名称。支持 Windows 时区和 Iana 时区。
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<converted-timestamp>	string	已转换为目标时区的时间戳

示例

此示例将时间戳从太平洋标准时间转换为 UTC

convertToUTC('01/01/2018 00:00:00', 'Pacific Standard Time')

并返回结果 2018-01-01T08:00:00.000Z。

示例 2

此示例将 de-DE 区域设置中的时间戳从太平洋标准时间转换为 UTC：

convertToUTC('01/01/2018 00:00:00', 'Pacific Standard Time', '', 'de-DE')

并返回结果 01.01.18 08:00:00。

createArray

从多个输入返回数组。

createArray('<object1>', '<object2>', ...)

参数	必选	类型	说明
<object1>, <object2>, ...	是	任意，但不能混用	至少两个用于创建数组的项

返回值	类型	说明
[<object1>, <object2>, ...]	数组	基于所有输入项创建的数组

示例

此示例基于以下输入创建数组：

createArray('h', 'e', 'l', 'l', 'o')

并返回结果 [h ,e, l, l, o]。

dataUri

返回字符串的数据统一资源标识符 (URI)。

dataUri('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的字符串

返回值	类型	描述
[<date-uri>]	string	输入字符串的数据 URI

示例

dataUri('hello')

返回结果“data:text/plain;charset=utf-8;base64,aGVsbG8=”。

dataUriToBinary

返回数据统一资源标识符 (URI) 的二进制版本。

dataUriToBinary('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的数据 URI

返回值	类型	描述
[<binary-for-data-uri>]	Byte Array	数据 URI 的二进制版本

示例

此示例创建以下数据 URI 的二进制版本：

dataUriToBinary('aGVsbG8=')

并返回结果“new byte[] { 97, 71, 86, 115, 98, 71, 56, 61 }”。

dataUriToString

返回数据统一资源标识符 (URI) 的字符串版本。

dataUriToString('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的数据 URI

返回值	类型	描述
[<string-for-data-uri>]	string	数据 URI 的字符串版本

示例

此示例基于以下数据 URI 创建字符串：

dataUriToString('data:text/plain;charset=utf-8;base64,aGVsbG8=')

并返回结果“hello”。

date

以 m/dd/yyyy 格式返回指定时间戳的日期。

date('<timestramp>')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串

返回值	类型	说明
<date>	string	指定时间戳的日期

date('2018-03-15T13:00:00.000Z')

返回结果 3-15-2018。

dateReadBack

使用日期时间库提供日期回读。

dateReadBack('<currentDate>', '<targetDate>')

参数	必选	类型	描述
<currentDate>	是	string	包含当前日期的字符串
<targetDate>	是	string	包含目标日期的字符串

返回值	类型	描述
<date-readback>	string	当前日期和目标日期之间的回读

示例 1

dateReadBack('2018-03-15T13:00:00.000Z', '2018-03-16T13:00:00.000Z')

返回结果“明天”。

dateTimeDiff

返回两个时间戳之间的差值。

dateTimeDiff('<timestamp1>', '<timestamp2>')

参数	必选	类型	描述
<timestamp1>	是	string	要比较的第一个字符串
<timestamp2>	是	string	要比较的第二个字符串

返回值	类型	描述
<ticks>	数字	两个时间戳之间的刻度差值

示例 1

此示例返回两个时间戳之间的刻度差值：

dateTimeDiff('2019-01-01T08:00:00.000Z','2018-01-01T08:00:00.000Z')

并返回数字 315360000000000。

示例 2

此示例返回两个时间戳之间的刻度差值：

dateTimeDiff('2018-01-01T08:00:00.000Z', '2019-01-01T08:00:00.000Z')

返回结果 -315360000000000。值为负数。

dayOfMonth

基于时间戳返回月中的某天。

dayOfMonth('<timestamp>')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串

返回值	类型	说明
<day-of-month>	integer	基于指定的时间戳返回月中的某天

示例

此示例基于以下时间戳返回一个月中的某一天：

dayOfMonth('2018-03-15T13:27:36Z')

并返回结果 15。

dayOfWeek

基于时间戳返回周几。

dayOfWeek('<timestamp>')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串

返回值	类型	说明
<day-of-week>	integer	基于指定的时间戳返回一周中的某一天。星期日为 0，星期一为 1，依此类推。

示例

此示例基于以下时间戳返回一个周中的某一天：

dayOfWeek('2018-03-15T13:27:36Z')

并返回结果 3。

dayOfYear

基于时间戳返回年中的某天。

dayOfYear('<timestamp>')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串

返回值	类型	说明
<day-of-year>	integer	基于指定的时间戳返回年中的某天

示例

此示例基于以下时间戳返回年中的某天：

dayOfYear('2018-03-15T13:27:36Z')

并返回结果 74。

div

返回将两个数字相除后的整数结果。若要返回余数，请参阅 mod()。

div(<dividend>, <divisor>)

参数	必选	类型	说明
<dividend>	是	number	要用作 divisor 的被除数的数字
<divisor>	是	number	除以被除数的数字。不能为 0。

返回值	类型	说明
<quotient-result>	数字	将第一个数字除以第二个数字后得到的结果

示例

两个示例都将第一个数字除以第二个数字：

div(10, 5)
div(11, 5)

并返回结果 2。

Javascript 和 .NET SDK 之间存在一些差异。例如，以下表达式将在 Javascript 和 .NET SDK 中返回不同的结果：

如果其中某个参数为浮点数，在.NET SDK中，则结果也为浮点数。

示例

div(11.2, 2)

返回结果 5.6。

如果其中一个参数是浮点数，则结果将是具有 Javascript SDK 的 INT。

示例

div(11.2, 2)

返回结果 5。

Javascript 在结果中保留一定数量的小数位数的解决方法是使用此类表达式。例如，若要保留 3 个小数位数：

float(concat(string(div(a, b)),'.',string(mod(div(a*1000, b), 1000))))

empty

检查实例是否为空。如果输入为空，则返回 true。空表示：

输入为 NULL 或未定义
输入为 NULL 或空字符串
输入为零大小的集合
输入为无属性的对象。

empty('<instance>')
empty([<instance>])

参数	必选	类型	描述
<实例>	是	any	要检查的实例

返回值	类型	说明
true 或 false	布尔	如果实例为空，则返回 `true`。

示例

这些示例检查指定的实例是否为空：

empty('')
empty('abc')
empty([1])
empty(null)

并分别返回以下结果：

传递一个空字符串，所以此函数返回 true。
传递字符串“abc”，所以此函数返回 false。
传递带有一个项的集合，所以此函数返回 false。
传递 NULL 对象，所以此函数返回 true。

endsWith

检查字符串是否以特定的子字符串结尾。如果找到 substring，返回 true；否则返回 false。此函数区分大小写。

endsWith('<text>', '<searchText>')

参数	必选	类型	说明
<text>	是	string	要检查的字符串
<searchText>	是	string	要查找的结尾子字符串

返回值	类型	说明
true 或 false	布尔	找到结尾 substring 时返回 `true`。如果找不到结尾 substring，则返回 `false`

示例 1

此示例检查“hello world”字符串是否以字符串“world”结尾：

endsWith('hello world', 'world')

它返回结果 true。

示例 2

此示例检查“hello world”字符串是否以字符串“universe”结尾：

endsWith('hello world', 'universe')

它返回结果 false。

EOL

返回行尾（EOL）序列的文本。

EOL()

返回值	类型	描述
<IsOSPlatform>	string	在 Windows 中返回 \r\n，在 Mac 和 Linux 中返回 \n。

示例

此示例检查行尾序列的文本：

EOL()

并返回以下字符串：

Windows: \r\n
Mac 或 Linux：\n

等于

检查两个值、表达式或对象是否相等。如果两者相等，返回 true；否则返回 false。

equals('<object1>', '<object2>')

参数	必选	类型	说明
<object1>, <object2>	是	any	要比较的值、表达式或对象

返回值	类型	说明
true 或 false	布尔	两者相等时返回 `true`。如果两者不相等，则返回 `false`。

示例

这些示例检查指定的输入是否相等：

equals(true, 1)
equals('abc', 'abcd')

并分别返回以下结果：

两个值相等，所以此函数返回 true。
两个值不相等，所以此函数返回 false。

exists

计算表达式的真假性。

exists(expression)

参数	必选	类型	说明
表达式	是	表达式	用于计算真假性的表达式

返回值	类型	说明
<true or false>	布尔	表达式的求值结果

示例

这些示例计算 foo = {"bar":"value"} 的真假性：

exists(foo.bar)
exists(foo.bar2)

并分别返回以下结果：

true
false

exp

返回 n 的 m 次幂。

exp(realNumber, exponentNumber)

参数	必选	类型	描述
realNumber	是	数字	要计算其指数的实数
exponentNumber	是	number	指数

返回值	类型	描述
<result-exp>	数字	计算 `realNumber` 的指数得出的结果

示例

此示例计算指数：

exp(2, 2)

并返回结果 4。

first

返回字符串或数组中的第一项。

first('<collection>')
first([<collection>])

参数	必选	类型	说明
<collection>	是	字符串或数组	要在其中查找第一项的集合

返回值	类型	说明
<first-collection-item>	any	集合中的第一项

示例

这些示例查找以下集合中的第一项：

first('hello')
first(createArray(0, 1, 2))

并分别返回以下结果：

平展 (flatten)

将数组平展为非数组值。可以选择设置要平展到的最大深度。

flatten([<collection>], '<depth>')

参数	必选	类型	说明
<collection>	是	数组	要平展的集合
<depth>	否	数字	要平展的最大深度。默认值为无穷大。

返回值	类型	描述
<new-collection>	array	新集合，其元素已平展为指定深度的非数组

示例 1

此示例平展以下数组：

flatten(createArray(1, createArray(2), createArray(createArray(3, 4), createArray(5, 6)))

并返回结果 [1, 2, 3, 4, 5, 6]。

示例 2

此示例将数组平展为深度 1：

flatten(createArray(1, createArray(2), createArray(createArray(3, 4), createArray(5, 6)), 1)

并返回结果 [1, 2, [3, 4], [5, 6]]。

FLOAT

将浮点数的字符串版本转换为浮点数。仅当将自定义参数传递给应用（例如，逻辑应用）时，才使用此函数。如果字符串无法转换为浮点数，将引发异常。

float('<value>')

参数	必选	类型	说明
<value>	是	string	具有要转换为有效浮点数的字符串

返回值	类型	说明
<float-value>	float	指定字符串的浮点数

示例

此示例转换字符串的浮点版本：

float('10.333')

并返回浮点 10.333。

floor

返回小于或等于指定数字的最大整数值。

floor('<number>')

参数	必选	类型	说明
<number>	是	number	输入数字

返回值	类型	描述
<整数值>	integer	小于或等于输入数字的最大整数值

示例

此示例计算数字 10.333 的下限值：

floor(10.333)

返回整数 10。

foreach

对每个元素执行操作并返回新集合。

foreach([<collection/instance>], <iteratorName>, <function>)

参数	必选	类型	描述
<collection/instance>	是	数组或对象	包含项的集合
<iteratorName>	是	迭代器名称	箭头函数的键项
<函数>	是	表达式	包含 `iteratorName` 的函数

返回值	类型	描述
<new-collection>	数组	一个新集合，其中每个元素都通过函数进行计算

示例 1

此示例生成新的集合：

foreach(createArray(0, 1, 2, 3), x, x + 1)

并返回结果 [1, 2, 3, 4]。

示例 2

此示例生成新的集合：

foreach(json("{'name': 'jack', 'age': '15'}"), x, concat(x.key, ':', x.value))
foreach(json("{'name': 'jack', 'age': '15'}"), x=> concat(x.key, ':', x.value))

并返回结果 ['name:jack', 'age:15']。请注意，第二个表达式是一个 lambda 表达式，有些表达式会发现更易读。

formatDateTime

以可选区域设置格式返回时间戳。

formatDateTime('<timestamp>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<reformatted-timestamp>	string	采用指定格式的更新后时间戳

示例 1

此示例将时间戳转换为指定的格式：

formatDateTime('03/15/2018 12:00:00', 'yyyy-MM-ddTHH:mm:ss')

并返回结果 2018-03-15T12:00:00。

示例 2

此示例转换 de-DE 区域设置中的时间戳：

formatDateTime('2018-03-15', '', 'de-DE')

并返回结果 15.03.18 00:00:00。

formatEpoch

以可选的区域设置格式从 UNIX 时间（也称为 Epoch 时间、POSIX 时间、UNIX Epoch 时间）返回指定格式的时间戳。

formatEpoch('<epoch>', '<format>'?, '<locale>'?)

参数	必选	类型	描述
<epoch>	是	数字	纪元编号
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<reformatted-timestamp>	string	采用指定格式的更新后时间戳

示例

此示例将 Unix 时间戳转换为指定的格式：

formatEpoch(1521118800, 'yyyy-MM-ddTHH:mm:ss.fffZ)'

并返回结果 2018-03-15T12:00:00.000Z。

示例

此示例在 de-DE 区域设置中转换 Unix 时间戳：

formatEpoch(1521118800, '', 'de-DE')

并返回结果 15.03.18 13:00:00。

formatNumber

将值格式化为指定的小数位数和可选的指定区域设置。

formatNumber('<number>', '<precision-digits>', '<locale>'?)

参数	必选	类型	说明
<number>	是	number	一个输入数字
<precision-digits>	是	integer	指定的小数位数
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	描述
<return-value>	数字	输入值按指定小数位数和指定区域设置格式化后的返回值

示例 1

此示例将数字 10.333 设置为 2 个小数位数：

formatNumber(10.333, 2)

返回字符串结果 10.33。

示例 2

这些示例将数字的格式设置为 en-US 区域设置中的指定位数：

formatNumber(12.123, 2, 'en-US')
formatNumber(1.551, 2, 'en-US')
formatNumber(12.123, 4, 'en-US')

并分别返回下列结果：

12.12
1.55
12.1230

formatTicks

从时钟周期返回指定格式的可选区域设置格式的时间戳。

formatTicks('<ticks>', '<format>'?, '<locale>'?)

参数	必选	类型	描述
<epoch>	是	number（或 Javascript 中的 bigint）	时钟周期数
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<reformatted-timestamp>	string	采用指定格式的更新后时间戳

示例 1

此示例将时钟周期转换为指定的格式：

formatTicks(637243624200000000, 'yyyy-MM-ddTHH:mm:ss.fffZ')

然后返回结果“2020-05-06T11:47:00.000Z”。

示例 2

此示例将时钟周期转换为在 de-DE 区域设置中指定的格式：

formatTicks(637243624200000000, '', 'de-DE')

然后返回结果 06.05.20 11:47:00。

getFutureTime

以可选的区域设置格式返回当前时间戳加上指定的时间单位。

getFutureTime(<interval>, <timeUnit>, '<format>'?, '<locale>'?)

参数	必选	类型	说明
<间隔>	是	integer	要添加的指定时间单位数
<timeUnit>	是	string	间隔使用的时间单位。可能的单位为“秒”、“分钟”、“小时”、“天”、“周”、“月”。
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<updated-timestamp>	string	当前时间戳加上指定的时间单位数

示例 1

假设当前时间戳是“2019-03-01T00:00:00.000Z”。下面的示例将 5 天添加到该时间戳：

getFutureTime(2, 'Week')

并返回结果 2019-03-15T00:00:00.000Z。

示例 2

假设当前时间戳是“2018-03-01T00:00:00.000Z”。下面的示例将 5 天添加到时间戳，并将结果转换为 MM-DD-YY 格式：

getFutureTime(5, 'Day', 'MM-DD-YY')

并返回结果 03-06-18。

示例 3

假设当前时间戳为 2020-05-01T00：00：00.000Z ，区域设置为 de-DE。下面的示例将 1 天添加到该时间戳：

getFutureTime(1,'Day', '', 'de-DE')

并返回结果 02.05.20 00:00:00。

getNextViableDate

根据当前日期和可选的指定时区返回 Timex 表达式的下一个可行日期。

getNextViableDate(<timexString>, <timezone>?)

参数	必选	类型	描述
<timexString>	是	string	要计算的日期的 Timex 字符串。
<timezone>	否	string	可选时区。

返回值	类型	描述
<nextViableTime>	string	下一个可行的日期。

示例

假设日期为 2020-06-12 ，当前时间为 15：42：21。

这些示例基于上述日期和时间评估下一个可行日期的 Timex 字符串：

getPreviousViableDate("XXXX-12-20", "America/Los_Angeles")
getPreviousViableDate("XXXX-02-29")

并分别返回以下字符串：

2020-12-20
2024-02-29

getNextViableTime

根据当前时间和可选的指定时区返回 Timex 表达式的下一个可行时间。

getNextViableTime(<timexString>, <timezone>?)

参数	必选	类型	描述
<timexString>	是	string	要计算的时间的 Timex 字符串。
<timezone>	否	string	可选时区。

返回值	类型	描述
<nextViableTime>	string	下一个可行的时间。

示例

假设日期为 2020-06-12 ，当前时间为 15：42：21。

这些示例基于上述日期和时间评估 Timex 字符串的下一个可行时间：

getNextViableTime("TXX:12:14", "Asia/Tokyo")
getNextViableTime("TXX:52:14")

并分别返回以下字符串：

T16:12:14
T15:52:14

getPastTime

返回当前时间戳减去指定的时间单位。

getPastTime(<interval>, <timeUnit>, '<format>'?)

参数	必选	类型	说明
<间隔>	是	integer	要减去的指定时间单位数
<timeUnit>	是	string	间隔使用的时间单位。可能的单位为“秒”、“分钟”、“小时”、“天”、“周”、“月”。
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。

返回值	类型	说明
<updated-timestamp>	string	当前时间戳减去指定的时间单位数

示例 1

假设当前时间戳是“2018-02-01T00:00:00.000Z”。此示例从该时间戳减去 5 天：

getPastTime(5, 'Day')

并返回结果 2019-01-27T00:00:00.000Z。

示例 2

假设当前时间戳是“2018-03-01T00:00:00.000Z”。此示例在 MM-DD-YY 格式的时间戳中减去了 5 天：

getPastTime(5, 'Day', 'MM-DD-YY')

并返回结果 02-26-18。

示例 3

假设当前时间戳为 2020-05-01T00：00：00.000Z ，区域设置为 de-DE。下面的示例从时间戳中减去 1 天：

getPastTime(1,'Day', '', 'de-DE')

并返回结果 31.04.20 00:00:00。

getPreviousViableDate

根据当前日期和可选的指定时区返回 Timex 表达式的上一个可行日期。

getPreviousViableDate(<timexString>, <timezone>?)

参数	必选	类型	描述
<timexString>	是	string	要计算的日期的 Timex 字符串。
<timezone>	否	string	可选时区。

返回值	类型	描述
<previousViableDate>	string	以前的可行日期。

示例

假设日期为 2020-06-12 ，当前时间为 15:42:21。

这些示例基于上述日期和时间评估上一个可行日期的 Timex 字符串：

getPreviousViableDate("XXXX-12-20", "Eastern Standard Time")
getPreviousViableDate("XXXX-02-29")

并分别返回以下字符串：

2019-12-20
2020-02-29

getPreviousViableTime

根据当前日期和可选的指定时区返回 Timex 表达式的上一个可行时间。

getPreviousViableTime(<timexString>, <timezone>?)

参数	必选	类型	描述
<timexString>	是	string	要计算的时间的 Timex 字符串。
<timezone>	否	string	可选时区。

返回值	类型	描述
<previousViableTime>	string	以前的可行时间。

示例

假设日期为 2020-06-12 ，当前时间为 15:42:21。

这些示例基于上述日期和时间评估以前的可行时间的 Timex 字符串：

getPreviousViableTime("TXX:52:14")
getPreviousViableTime("TXX:12:14", 'Europe/London')

并分别返回以下字符串：

T14:52:14
T15:12:14

getProperty

从 JSON 对象返回指定属性或根属性的值。

返回指定属性键的值

getProperty(<JSONObject>, '<propertyName>')

参数	必选	类型	描述
<JSONObject>	是	对象 (object)	JSON 对象包含属性和值。
<propertyName>	否	string	要从中访问值的可选属性的名称。

返回值	类型	说明
value	string	JSON 对象中指定属性的值。

示例

假设你拥有以下 JSON 对象：

{
   "a:b" : "a:b value",
   "c":
   {
        "d": "d key"
    }
}

这些示例从上述 JSON 对象中检索指定属性：

getProperty({"a:b": "value"}, 'a:b')
getProperty(c, 'd')

并分别返回以下字符串：

a：b 值
d 键

返回根属性

getProperty('<propertyName>')

参数	必选	类型	描述
<propertyName>	是	string	从根内存范围访问值的可选属性的名称。

返回值	类型	说明
value	string	JSON 对象中根属性的值。

示例

假设你拥有以下 JSON 对象：

{
   "a:b" : "a:b value",
   "c":
   {
        "d": "d key"
    }
}

此示例从上述 JSON 对象检索根属性：

getProperty("a:b")

并返回字符串a:b 值。

getTimeOfDay

返回给定时间戳的一天中的某个时间。

getTimeOfDay('<timestamp>')

返回的时间是以下某个字符串：

参数	必选	类型	说明
<timestamp>	是	string	包含指定时间戳的字符串

返回值	类型	描述
<time-of-day>	string	指定的时间戳的一天中的某个时间

下面列出了与一天中的某个时间关联的字符串：

一天中的某个时间	Timestamp
午夜	午夜 12 点
上午	上午 12:01 - 中午 11:59
中午	中午 12 点
晚上	下午 06:00 - 晚上 10:00
夜间	晚上 10:01 - 晚上 11:59

示例

getTimeOfDay('2018-03-15T08:00:00.000Z')

返回结果“上午”。

greater

检查第一个值是否大于第二个值。如果第一个值更大，则返回 true；否则返回 false。

greater(<value>, <compareTo>)
greater('<value>', '<compareTo>')

参数	必选	类型	说明
<value>	是	整数、float 或字符串	要检查是否大于第二个值的第一个值。
<compareTo>	是	分别为整数、float 或字符串	比较值

返回值	类型	说明
true 或 false	布尔	如果第一个值大于第二个值，返回 `true`。如果第一个值等于或小于第二个值，返回 `false`。

示例

这些示例检查第一个值是否大于第二个值：

greater(10, 5)
greater('apple', 'banana')

并分别返回下列结果：

true
false

greaterOrEquals

检查第一个值是否大于或等于第二个值。当第一个值大于或等于第二个值时，则返回 true；否则返回 false。

greaterOrEquals(<value>, <compareTo>)
greaterOrEquals('<value>', '<compareTo>')

参数	必选	类型	说明
<value>	是	整数、float 或字符串	要检查是否大于或等于第二个值的第一个值
<compareTo>	是	分别为整数、float 或字符串	比较值

返回值	类型	说明
true 或 false	布尔	如果第一个值大于或等于第二个值，返回 `true`。如果第一个值小于第二个值，返回 `false`。

示例

这些示例检查第一个值是否大于或等于第二个值：

greaterOrEquals(5, 5)
greaterOrEquals('apple', 'banana')

并分别返回下列结果：

true
false

if

检查表达式为 true 还是 false。根据结果返回指定的值。

if(<expression>, <valueIfTrue>, <valueIfFalse>)

参数	必选	类型	说明
<expression>	是	Boolean	要检查的表达式
<valueIfTrue>	是	any	表达式为 true 时要返回的值
<valueIfFalse>	是	any	表达式为 false 时要返回的值

返回值	类型	说明
<specified-return-value>	any	根据表达式为 `true` 还是 `false` 返回的指定值

示例

此示例计算 equals(1,1) 是否为 true：

if(equals(1, 1), 'yes', 'no')

并返回 yes，因为指定的表达式返回 true。否则，此示例返回 no。

indexOf

返回 substring 的起始位置或索引值。此函数区分大小写，并且索引从数字 0 开始。

indexOf('<text>', '<searchText>')

参数	必选	类型	说明
<text>	是	字符串或数组	包含要查找的子字符串的字符串
<searchText>	是	string	要查找的子字符串

返回值	类型	说明
<index-value>	integer	指定的 substring 的起始位置或索引值。
如果未找到该字符串，则返回数字 -1。

示例 1

此示例查找字符串“hello world”中的 substring“world”的起始索引值：

indexOf('hello world', 'world')

并返回结果 6。

示例 2

此示例查找数组 ['abc', 'def', 'ghi'] 中的 substring def 的起始索引值：

indexOf(createArray('abc', 'def', 'ghi'), 'def')

并返回结果 1。

indicesAndValues

将一个数组或对象变成具有索引（当前索引）和值属性的多个对象的数组。对于数组，索引是数组中的位置。对于对象，它是值的键。

indicesAndValues('<collection or object>')

参数	必选	类型	描述
<collection or object>	是	数组或对象	原始数组或对象

返回值	类型	说明
<collection>	数组	新数组。每个项都具有两个属性：带有数组位置或对象键的索引以及相应的值。

示例 1

假设你有一个列表 { items: ["zero", "one", "two"] }。下面的函数使用该列表：

indicesAndValues(items)

并返回一个新列表：

[
  {
    index: 0,
    value: 'zero'
  },
  {
    index: 1,
    value: 'one'
  },
  {
    index: 2,
    value: 'two'
  }
]

示例 2

假设你有一个列表 { items: ["zero", "one", "two"] }。下面的函数使用该列表：

where(indicesAndValues(items), elt, elt.index >= 1)

并返回一个新列表：

[
  {
    index: 1,
    value: 'one'
  },
  {
    index: 2,
    value: 'two'
  }
]

示例 3

假设你有一个列表 { items: ["zero", "one", "two"] }。下面的函数使用该列表：

join(foreach(indicesAndValues(items), item, item.value), ',')

并返回结果 0、1、2。此表达式与 join(items, ',') 具有相同的效果。

示例 4

假设你有一个对象 { user: {name: 'jack', age: 20} }。下面的函数使用该对象：

indicesAndValues(user)

并返回一个新的对象：

[
  {
    index: 'name',
    value: 'jack'
  },
  {
    index: 'age',
    value: 20
  }
]

int

返回字符串的整数版本。如果字符串无法转换为整数，将引发异常。

int('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的字符串

返回值	类型	说明
<integer-result>	integer	指定的字符串的整数版本

示例

此示例创建字符串“10”的整数版本：

int('10')

并以整数 10 的形式返回结果。

intersection

返回其中仅包含指定集合的共有项的一个集合。某个项必须出现在传递给此函数的所有集合中才会出现在结果中。如果一个或多个项具有相同的名称，则具有该名称的最后一项将出现在结果中。

intersection([<collection1>], [<collection2>], ...)
intersection('<collection1>', '<collection2>', ...)

参数	必选	类型	描述
<collection1>, <collection2>	是	数组或对象，但不能同时为两者	只需要其中共有项的各个集合

返回值	类型	说明
<common-items>	分别为数组或对象	其中仅包含指定集合的共有项的一个集合

示例

此示例查找以下数组中的共有项：

intersection(createArray(1, 2, 3), createArray(101, 2, 1, 10), createArray(6, 8, 1, 2))

并返回只包含项 [1, 2] 的数组。

isArray

如果给定输入为数组，则返回 true。

isArray('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	如果给定输入为数组，则返回 `true`；否则返回 `false`。

示例

以下示例检查输入是否为数组：

isArray('hello')
isArray(createArray('hello', 'world'))

并分别返回下列结果：

输入为字符串，所以函数返回 false。
输入为数组，因此函数返回 true。

isBoolean

如果给定输入为布尔值，则返回 true。

isBoolean('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	如果给定输入为布尔值，则返回 `true`；否则返回 `false`。

示例

以下示例检查输入是否为布尔值：

isBoolean('hello')
isBoolean(32 > 16)

并分别返回下列结果：

输入为字符串，所以函数返回 false。
输入为布尔值，所以函数返回 true。

isDate

如果给定 TimexProperty 或 Timex 表达式引用有效日期，则返回 true。有效日期包含月份和 dayOfMonth，或者包含 dayOfWeek。

isDate('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象或 Timex 表达式字符串。

返回值	类型	说明
<boolean-result>	布尔	如果输入引用有效日期，则返回 `true`；否则返回 `false`。

示例

这些示例检查以下输入是否为有效日期：

isDate('2020-12')
isDate('xxxx-12-21')

并返回以下结果：

false
true

isDateRange

如果给定 TimexProperty 或 Timex 表达式引用有效日期范围，则返回 true。

isDateRange('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象，即 Timex 表达式字符串。

返回值	类型	说明
<boolean-result>	布尔	如果给定输入引用的是有效的日期范围，则返回 `true`；否则返回 `false`。

示例

这些示例检查以下输入是否为有效日期范围：

isDateRange('PT30M')
isDateRange('2012-02')

并返回以下结果：

false
true

isDateTime

如果给定输入是 UTC ISO 格式 (YYYY-MM-DDTHH:mm:ss.fffZ) 时间戳字符串，则返回 true。

isDateTime('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	如果给定输入是 UTC ISO 格式的时间戳字符串，则返回 `true`；否则返回 `false`。

示例

以下示例检查输入是否为 UTC ISO 格式字符串：

isDateTime('hello world!')
isDateTime('2019-03-01T00:00:00.000Z')

并分别返回下列结果：

输入为字符串，所以函数返回 false。
输入为 UTC ISO 格式字符串，所以函数返回 true。

isDefinite

如果给定 TimexProperty 或 Timex 表达式引用有效日期，则返回 true。有效日期包含年、月和 dayOfMonth。

isDefinite('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象，即 Timex 表达式字符串。

返回值	类型	说明
<boolean-result>	布尔	如果给定输入引用的是有效的完整日期，则返回 `true`；否则返回 `false`。

示例

假设存在一个 TimexProperty 对象 validFullDate = new TimexProperty("2020-02-20")，并将 Now 属性设置为 true。下面的示例检查对象是否引用的是有效的完整日期：

isDefinite('xxxx-12-21')
isDefinite(validFullDate)

并分别返回下列结果：

false
true

isDuration

如果给定 TimexProperty 或 Timex 表达式引用有效持续时间，则返回 true。

isDuration('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象，即 Timex 表达式字符串。

返回值	类型	说明
<boolean-result>	布尔	如果输入引用的是有效持续时间，则返回 `true`；否则返回 `false`。

示例

下面的示例检查以下输入是否引用的是有效持续时间：

isDuration('PT30M')
isDuration('2012-02')

并分别返回下列结果：

true
false

isFloat

如果给定输入为浮点数，则返回 true。由于 C# 与 JavaScript 之间的调整方式，其取模为 1、余数不为零的数字将被视为浮点数。

isFloat('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	如果给定输入为浮点数，则返回 `true`；否则返回 `false`。

示例

以下示例检查输入是否为浮点数：

isFloat('hello world!')
isFloat(1.0)
isFloat(12.01)

并分别返回下列结果：

输入为字符串，所以函数返回 false。
输入的取模等于 0，因此函数返回 false。
输入是浮点数，因此函数返回 true。

isInteger

如果给定输入为整数，则返回 true。由于 C# 和 JavaScript 之间的对齐方式，其取模为 1、余数为零的数字将被视为整数。

isInteger('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	输入是否为整数

示例

以下示例检查输入是否为整数：

isInteger('hello world!')
isInteger(1.0)
isInteger(12)

并分别返回下列结果：

输入为字符串，所以函数返回 false。
输入的取模等于 0，因此函数返回 true。
输入为整数，因此函数返回 true。

isMatch

如果给定的字符串与指定的正则表达式模式匹配，则返回 true。

isMatch('<target**string>', '<pattern>')

参数	必选	类型	描述
<targetstring>	是	string	要匹配的字符串
<pattern>	是	string	正则表达式模式

返回值	类型	说明
<Boolean-result>	布尔	如果给定的字符串与常见的正则表达式模式匹配，则返回 `true`；否则返回 `false`。

示例

下面的示例检查输入是否匹配指定的正则表达式模式：

isMatch('ab', '^[a-z]{1,2}$')
isMatch('FUTURE', '(?i)fortune|future')
isMatch('12abc34', '([0-9]+)([a-z]+)([0-9]+)')
isMatch('abacaxc', 'ab.*?c')

并返回相同的结果 true。

isObject

如果给定输入是复杂对象，则返回 true；如果给定输入是基元对象，则返回 false。基元对象包括字符串、数字和布尔值；复杂类型（如类）包含属性。

isObject('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	如果给定输入是复杂对象，则返回 `true`；如果给定输入是基元对象，则返回 `false`。

示例

以下示例检查给定输入是否为对象：

isObject('hello world!')
isObject({userName: "Sam"})

并分别返回下列结果：

输入为字符串，所以函数返回 false。
输入为对象，因此函数返回 true。

isPresent

如果给定 TimexProperty 或 Timex 表达式引用当前日期，则返回 true。

isPresent('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象，即 Timex 表达式字符串

返回值	类型	说明
<boolean-result>	布尔	如果输入引用当前日期，则返回 `true`；否则返回 false。

示例假设我们有一个 TimexProperty 对象 validNow = new TimexProperty() { Now = true }，并将 Now 属性设置为 true。下面的示例检查以下输入是否引用的是当前日期：

isPresent('PT30M')
isPresent(validNow)

并分别返回下列结果：

false
true

isString

如果给定输入为字符串，则返回 true。

isString('<input>')

参数	必选	类型	描述
<input>	是	any	要测试的输入

返回值	类型	说明
<Boolean-result>	布尔	如果给定输入为字符串，则返回 `true`；否则返回 `false`。

示例

以下示例检查给定输入是否为字符串：

isString('hello world!')
isString(3.14)

并分别返回下列结果：

输入为字符串，所以函数返回 true。
输入为 float，所以函数返回 false。

isTime

如果给定 TimexProperty 或 Timex 表达式引用有效时间，则返回 true。有效时间包含小时数、分钟数和秒数。

isTime('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象，即 Timex 表达式字符串

返回值	类型	说明
<boolean-result>	布尔	如果输入引用的是有效时间，则返回 `true`；否则返回 `false`。

示例

这些示例检查以下输入是否为有效时间：

isTime('PT30M')
isTime('2012-02-21T12:30:45')

并分别返回下列结果：

false
true

isTimeRange

如果给定 TimexProperty 或 Timex 表达式引用有效时间范围，则返回 true。有效时间范围包含 partOfDay。

isTime('<input>')

参数	必选	类型	描述
<input>	是	对象或字符串	输入 TimexProperty 对象，即 Timex 表达式字符串。

返回值	类型	说明
<boolean-result>	布尔	如果输入引用的是有效时间范围，则返回 `true`；否则返回 `false`。

示例

假设我们有一个 TimexProperty 对象 validTimeRange = new TimexProperty() { PartOfDay = "morning" }，并将 Now 属性设置为 true。这些示例检查以下输入是否为有效时间范围：

isTimeRange('PT30M')
isTimeRange(validTimeRange)

并分别返回下列结果：

false
true

join

返回一个字符串，它包含某个数组中的所有项，其中每个字符都用分隔符分隔。

join([<collection>], '<delimiter>')

参数	必选	类型	说明
<collection>	是	数组	包含要联接的项的数组
<delimiter>	是	string	出现在结果字符串中的每个字符之间的分隔符

返回值	类型	说明
<char1><delimiter><char2><delimiter>...	string	基于指定数组中的所有项创建的结果字符串

示例

此示例基于以下数组中的所有项创建字符串，并且以指定的字符 . 作为分隔符：

join(createArray('a', 'b', 'c'), '.')

并返回结果 a.b.c。

jPath

检查 JSON 或 JSON 字符串中与路径表达式匹配的节点或值，然后返回匹配的节点。

jPath(<json>, '<path>')

参数	必选	类型	描述
<json>	是	any	要在其中搜索与路径表达式值匹配的节点或值的 JSON 对象或字符串
<路径>	是	any	用来查找匹配的 JSON 节点或值的路径表达式

返回值	类型	描述
[ <json-node>]	array	与指定路径表达式匹配的 JSON 节点或值的列表

C# 示例

假设你拥有以下 JSON：

{
    "Stores": [
        "Lambton Quay",
        "Willis Street"
    ],
    "Manufacturers": [
        {
            "Name": "Acme Co",
            "Products": [
                {
                    "Name": "Anvil",
                    "Price": 50
                }
            ]
        },
        {
            "Name": "Contoso",
            "Products": [
                {
                    "Name": "Elbow Grease",
                    "Price": 99.95
                },
                {
                    "Name": "Headlight Fluid",
                    "Price": 4
                }
            ]
        }
    ]
}

路径表达式为 $..Products[?(@.Price >= 50)].Name

jPath(jsonStr, path)

并返回结果 ["Anvil", "Elbow Grease"]。

Javascript 示例

假设你拥有以下 JSON：

{
    "automobiles": [
        {
            "maker": "Nissan",
            "model": "Teana",
            "year": 2011
        },
        {
            "maker": "Honda",
            "model": "Jazz",
            "year": 2010
        },
        {
            "maker": "Honda",
            "model": "Civic",
            "year": 2007
        },
        {
            "maker": "Toyota",
            "model": "Yaris",
            "year": 2008
        },
        {
            "maker": "Honda",
            "model": "Accord",
            "year": 2011
        }
    ],
    "motorcycles": [
        {
            "maker": "Honda",
            "model": "ST1300",
            "year": 2012
        }
    ]
}

路径表达式是 .automobiles{.maker === "Honda" && .year > 2009}.model。

jPath(jsonStr, path)

并返回结果 ['Jazz', 'Accord']。

json

返回字符串或 XML 的 JavaScript 对象表示法 (JSON) 类型的值或对象。

json('<value>')

参数	必选	类型	说明
<value>	是	字符串或 XML	要转换的字符串或 XML

返回值	类型	说明
<JSON-result>	string	从指定的字符串或 XML 创建的结果 JSON 对象。

示例 1

此示例将字符串转换为 JSON：

json('{"fullName": "Sophia Owen"}')

并返回结果：

{
  "fullName": "Sophia Owen"
}

示例 2

此示例将 XML 转换为 JSON：

json(xml('<?xml version="1.0"?> <root> <person id='1'> <name>Sophia Owen</name> <occupation>Engineer</occupation> </person> </root>'))

并返回结果：

{
   "?xml": { "@version": "1.0" },
   "root": {
      "person": [ {
         "@id": "1",
         "name": "Sophia Owen",
         "occupation": "Engineer"
      } ]
   }
}

jsonStringify

返回值的 JSON 字符串。

参数	必选	类型	说明
<value>	是	对象 (object)	要转换为 JSON 字符串的对象

返回值	类型	说明
<JSON-result>	string	生成的 JSON 字符串。

示例

这些示例显示转换为 JSON 字符串的对象：

jsonStringify(null)
jsonStringify({a:'b'})

并分别返回下列字符串结果：

null
{"a":"b"}

last

返回集合中的最后一个项。

last('<collection>')
last([<collection>])

参数	必选	类型	说明
<collection>	是	字符串或数组	要在其中查找最后一项的集合

返回值	类型	说明
<last-collection-item>	分别为字符串或数组	集合中的最后一项

示例

这些示例查找以下集合中的最后一项：

last('abcd')
last(createArray(0, 1, 2, 3))

并分别返回下列结果：

lastIndexOf

返回最后一次出现的 substring 的起始位置或索引值。此函数区分大小写，并且索引从数字 0 开始。

lastIndexOf('<text>', '<searchText>')

参数	必选	类型	说明
<text>	是	字符串或数组	包含要查找的子字符串的字符串
<searchText>	是	string	要查找的子字符串

返回值	类型	说明
<ending-index-value>	integer	最后一次出现的指定 substring 的起始位置或索引值。如果未找到该字符串，则返回数字 -1。

示例 1

此示例查找“hello world”字符串中最后一次出现的 substring“world”的起始索引值：

lastIndexOf('hello world', 'world')

并返回结果 6。

示例 2

此示例查找数组 ['abc', 'def', 'ghi', 'def'] 中最后一次出现的 substring def 的起始索引值。

lastIndexOf(createArray('abc', 'def', 'ghi', 'def'), 'def')

并返回结果 3。

length

返回字符串的长度。

length('<str>')

参数	必选	类型	描述
<str>	是	string	要计算长度的字符串

返回值	类型	描述
<length>	integer	该字符串的长度

示例

这些示例获取字符串的长度：

length('hello')
length('hello world')

并分别返回下列结果：

less

检查第一个值是否小于第二个值。如果第一个值更小，则返回 true；否则返回 false。

less(<value>, <compareTo>)
less('<value>', '<compareTo>')

参数	必选	类型	说明
<value>	是	整数、float 或字符串	要检查是否小于第二个值的第一个值
<compareTo>	是	分别为整数、float 或字符串	比较项

返回值	类型	说明
true 或 false	布尔	如果第一个值小于第二个值，返回 `true`。如果第一个值等于或大于第二个值，返回 `false`。

示例

这些示例检查第一个值是否小于第二个值。

less(5, 10)
less('banana', 'apple')

并分别返回下列结果：

true
false

lessOrEquals

检查第一个值是否小于或等于第二个值。如果第一个值小于或等于第二个值，则返回 true；否则返回 false。

lessOrEquals(<value>, <compareTo>)
lessOrEquals('<value>', '<compareTo>')

参数	必选	类型	说明
<value>	是	整数、float 或字符串	要检查是否小于或等于第二个值的第一个值
<compareTo>	是	分别为整数、float 或字符串	比较项

返回值	类型	说明
true 或 false	布尔	如果第一个值小于或等于第二个值，则返回 `true`。如果第一个值大于第二个值，返回 `false`。

示例

这些示例检查第一个值是否小于或等于第二个值。

lessOrEquals(10, 10)
lessOrEquals('apply', 'apple')

并分别返回下列结果：

true
false

max

返回列表或数组中的最大值。列表或数组两端的项也包含在内。

max(<number1>, <number2>, ...)
max([<number1>, <number2>, ...])

参数	必选	类型	说明
<number1>, <number2>, ...	是	数字	需要从中获取最大值的数字集
[<number1>, <number2>, ...]	是	数字数组	需要从中获取最大值的数字数组

返回值	类型	说明
<max-value>	数字	指定的数组或数字集中的最大值

示例

这些示例获取数字集和数组中的最大值：

max(1, 2, 3)
max(createArray(1, 2, 3))

并返回结果 3。

merge

将多个 JSON 对象或对象数组合并在一起。

merge(<json1>, <json2>, ...)

参数	必选	类型	描述
<json1>、 <json2>、...	是	对象或数组	要合并的 JSON 对象或数组集。

返回值	类型	说明
<result>	object	合并的 JSON 对象或组合的数组对象。

示例

假设你拥有以下 JSON 对象：

json1 = @"{
            'FirstName': 'John',
            'LastName': 'Smith',
            'Enabled': false,
            'Roles': [ 'User' ]
          }"
json2 =@"{
            'Enabled': true,
            'Roles': [ 'User', 'Admin' ]
          }"

此示例合并 JSON 对象：

string(merge(json(json1), json(json2)))

并返回生成的对象 {"FirstName":"John","LastName":"Smith","Enabled":true,"Roles":["User","Admin"]}。

假设你想要将对象和对象列表组合在一起。以下示例合并了 JSON 对象和对象数组：

merge({k1:'v1'}, [{k2:'v2'}, {k3: 'v3'}], {k4:'v4'})

并返回对象 { "k1": "v1", "k2": "v2", "k3": "v3", "k4": "v4" }。

min

返回一组数字或数组中的最小值。

min(<number1>, <number2>, ...)
min([<number1>, <number2>, ...])

参数	必选	类型	说明
<number1>, <number2>, ...	是	number	需要从中获取最小值的数字集
[<number1>, <number2>, ...]	是	数字数组	需要从中获取最小值的数字数组

返回值	类型	说明
<min-value>	数字	指定的数组或数字集中的最小值

示例

这些示例获取数字集和数组中的最小值：

min(1, 2, 3)
min(createArray(1, 2, 3))

并返回结果 1。

mod

返回将两个数字相除后的余数。若要获取整数结果，请参阅 div()。

mod(<dividend>, <divisor>)

参数	必选	类型	说明
<dividend>	是	number	要用作 divisor 的被除数的数字
<divisor>	是	number	除以被除数的数字。不能为 0。

返回值	类型	说明
<modulo-result>	数字	将第一个数字除以第二个数字后得到的余数

示例

此示例将第一个数字除以第二个数字：

mod(3, 2)

并返回结果 1。

月

返回指定时间戳的月份。

month('<timestamp>')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串

返回值	类型	描述
<number-of-month>	integer	指定时间戳中的月份数

示例

month('2018-03-15T13:01:00.000Z')

它返回结果 3。

mul

返回将两个数字相乘得到的乘积。

mul(<multiplicand1>, <multiplicand2>)

参数	必选	类型	说明
<multiplicand1>	是	整数或 float	要与 multiplicand2 相乘的数字
<multiplicand2>	是	整数或 float	要与 multiplicand1 相乘的数字

返回值	类型	说明
<product-result>	整数或 float	将第一个数字乘以第二个数字后得到的乘积

示例

这些示例将第一个数字乘以第二个数字：

mul(1, 2)
mul(1.5, 2)

并分别返回下列结果：

newGuid

返回新的 Guid 字符串。

newGuid()

返回值	类型	描述
<Guid-string>	string	新的 Guid 字符串，长度为 36，如下所示 xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx

示例

newGuid()

它返回格式为 xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx 的结果。

not

检查表达式是否为 false。如果表达式为 false，则返回 true；如果表达式为 true，则返回 false。

not(<expression>)

参数	必选	类型	说明
<expression>	是	Boolean	要检查的表达式

返回值	类型	说明
true 或 false	布尔	如果表达式为 false，则返回 `true`。如果表达式为 true，则返回 `false`。

示例 1

这些示例检查指定的表达式是否为 false：

not(false)
not(true)

并分别返回下列结果：

表达式为 false，所以此函数返回 true。
表达式为 true，所以此函数返回 false。

示例 2

这些示例检查指定的表达式是否为 false：

not(equals(1, 2))
not(equals(1, 1))

并分别返回下列结果：

表达式为 false，所以此函数返回 true。
表达式为 true，所以此函数返回 false。

或

检查是否至少一个表达式为 true。如果至少一个表达式为 true，则返回 true；如果所有表达式均为 false，则返回 false。

or(<expression1>, <expression2>, ...)

参数	必选	类型	说明
<expression1>、<expression2>，...	是	Boolean	要检查的表达式

返回值	类型	说明
true 或 false	布尔	如果至少一个表达式为 true，返回 `true`。如果所有表达式均为 false，返回 `false`。

示例 1

这些示例检查是否至少一个表达式为 true：

or(true, false)
or(false, false)

并分别返回下列结果：

至少一个表达式为 true，所以此函数返回 true。
两个表达式均为 false，所以此函数返回 false。

示例 2

这些示例检查是否至少一个表达式为 true：

or(equals(1, 1), equals(1, 2))
or(equals(1, 2), equals(1, 3))

并分别返回下列结果：

至少一个表达式为 true，所以此函数返回 true。
两个表达式均为 false，所以此函数返回 false。

rand

返回指定范围（仅包括起端在内）中的一个随机整数。

rand(<minValue>, <maxValue>)

参数	必选	类型	说明
<minValue>	是	integer	范围中的最小整数
<maxValue>	是	integer	此函数可以返回的范围中的最大整数之后的整数

返回值	类型	说明
<random-result>	integer	从指定范围中返回的随机整数

示例

此示例从指定范围内获取一个随机整数，不包括最大值：

rand(1, 5)

并返回结果 1、2、3 或 4。

range

返回以指定整数开头的一个整数数组。

range(<startIndex>, <count>)

参数	必选	类型	说明
<startIndex>	是	integer	作为数组开头的第一项的整数值
<count>	是	integer	数组中的整数个数

返回值	类型	描述
<range-result>	integer	从指定索引开始的整数组成的数组

示例

此示例创建一个整数数组，该数组从指定索引 1 开始，并包含指定的整数 4：

range(1, 4)

并返回结果 [1, 2, 3, 4]。

removeProperty

从对象中删除属性，并返回更新后的对象。

removeProperty(<object>, '<property>')

参数	必选	类型	说明
<object>	是	对象 (object)	要从中删除属性的 JSON 对象
<property>	是	string	要删除的属性名称

返回值	类型	说明
<updated-object>	object	不具有指定属性的更新后 JSON 对象

示例

此示例从 customerProfile 对象（该对象通过 json() 函数转换为 JSON）中删除 accountLocation 属性，并返回更新后的对象：

removeProperty(json('customerProfile'), 'accountLocation')

replace

将子字符串替换为指定字符串，并返回结果字符串。此函数区分大小写。

replace('<text>', '<oldText>', '<newText>')

参数	必选	类型	说明
<text>	是	string	包含要替换的子字符串的字符串
<oldText>	是	string	要替换的子字符串
<newText>	是	string	替换字符串

返回值	类型	说明
<updated-text>	string	替换 substring 后得到的更新后字符串。如果未找到子字符串，则该函数返回原始字符串。

示例 1

此示例查找“the old string”中的 substring“old”并将“old”替换为“new”：

replace('the old string', 'old', 'new')

结果是字符串“the new string”。

示例 2

在处理转义字符时，表达式引擎会使用 unescape 函数。此函数将字符串替换为转义字符。

replace('hello\"', '\"', '\n')
replace('hello\n', '\n', '\\\\')
@"replace('hello\\', '\\', '\\\\')"
@"replace('hello\n', '\n', '\\\\')"

并分别返回下列结果：

hello\n
hello\\
@"hello\\"
@"hello\\"

replaceIgnoreCase

将子字符串替换为指定字符串，并返回结果字符串。此函数区分大小写。

replaceIgnoreCase('<text>', '<oldText>', '<newText>')

参数	必选	类型	说明
<text>	是	string	包含要替换的子字符串的字符串
<oldText>	是	string	要替换的子字符串
<newText>	是	string	替换字符串

返回值	类型	说明
<updated-text>	string	替换 substring 后得到的更新后字符串。如果未找到子字符串，则返回原始字符串。

示例

此示例查找字符串“the old string”中的 substring“old”并将“old”替换为“new”：

replace('the old string', 'old', 'new')

并返回结果“the new string”。

resolve

如果给定 TimexProperty 或 Timex 表达式引用有效时间，则返回字符串。有效时间包含小时数、分钟数和秒数。

resolve('<timestamp')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串。

返回值	类型	描述
<return>	string	TimexProperty 对象或 Timex 表达式字符串。

示例

这些示例显示给定字符串是否引用有效时间：

resolve(T14)
resolve(2020-12-20)
resolve(2020-12-20T14:20)

并分别返回下列结果：

14:00:00
2020-12-20
2020-12-20 14:20:00

reverse

反转字符串或数组中元素的顺序。

reverse(<value>)

参数	必选	类型	说明
<value>	是	字符串或数组	要反转的数组的字符串。

返回值	类型	描述
<return>	字符串或数组	字符串或数组的反转元素。

示例

这些示例将反转字符串或数组的元素：

reverse(hello)
reverse(concat(hello,world))

并分别返回以下值：

-字符串 olleh。 -字符串 dlrowolleh。

round

将值舍入到最接近的整数或指定的小数位数。

round('<number>', '<precision-digits>')

参数	必选	类型	说明
<number>	是	number	一个输入数字
<precision-digits>	否	integer	指定的小数位数。默认值为 0。

返回值	类型	描述
<return-value>	数字	输入的返回值舍入为指定数量的小数位数

示例 1

此示例对数字 10.333 进行舍入：

round(10.333)

并返回数字 10。

示例 2

此示例将数字 10.3313 舍入为 2 个小数位数：

round(10.3313, 2)

并返回数字 10.33。

SELECT…

对每个元素执行操作并返回转换后的元素的新集合。

select([<collection/instance>], <iteratorName>, <function>)

参数	必选	类型	描述
<collection/instance>	是	array	包含项的集合
<iteratorName>	是	迭代器名称	键项
<函数>	是	表达式	可包含 `iteratorName` 的函数

返回值	类型	描述
<new-collection>	array	一个新集合，其中每个元素都使用函数进行计算

示例 1

此示例生成新的集合：

select(createArray(0, 1, 2, 3), x, x + 1)

并返回结果 [1, 2, 3, 4]。

示例 2

此示例生成新的集合：

select(json("{'name': 'jack', 'age': '15'}"), x, concat(x.key, ':', x.value))
select(json("{'name': 'jack', 'age': '15'}"), x=> concat(x.key, ':', x.value))

并返回结果 ['name:jack', 'age:15']。请注意，第二个表达式是 lambda 表达式，有些表达式会发现更易读。

sentenceCase

以可选的区域设置格式将字符串中第一个单词的第一个字母大写。

sentenceCase('<text>', '<locale>'?)

参数	必选	类型	说明
<text>	是	string	原始字符串
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	描述
结果字符串	string	返回句子事例结果

示例 1

以下示例将字符串中的第一个字母大写：

sentenceCase('a')
sentenceCase('abc def')
sentenceCase('aBC dEF')

并分别返回下列结果：

A
Abc def
Abc def

Example 2

这些示例将字符串中的第一个字母以指定的区域设置格式大写：

sentenceCase('a', 'fr-FR')
sentenceCase('abc', 'en-US')
sentenceCase('aBC', 'fr-FR')

并分别返回下列结果：

A
Abc
Abc

setPathToValue

从 JSON 对象检索指定属性的值。

setPathToValue(<path>, <value>)

参数	必选	类型	描述
<路径>	是	对象 (object)	要设置的路径
<value>	是	对象 (object)	要为路径设置的值

返回值	类型	说明
值	对象 (object)	要设置的值

示例 1

下面的示例将路径的值设置为 1：

setPathToValue(path.x, 1)

并返回结果 1。 path.x 设置为 1。

示例 2

下面的示例设置值：

setPathToValue(path.array[0], 7) + path.array[0]

并返回结果 14。

setProperty

设置对象的属性值并返回更新后的对象。若要添加新属性，请使用此函数或 addProperty() 函数。

setProperty(<object>, '<property>', <value>)

参数	必选	类型	说明
<object>	是	对象 (object)	要在其中设置属性的 JSON 对象
<property>	是	string	要设置的属性名称
<value>	是	any	要为指定属性设置的值

返回值	类型	说明
<updated-object>	object	设置了其属性的更新后 JSON 对象

示例

此示例在 customerProfile 对象（它通过 json() 函数转换为 JSON）上设置 accountNumber 属性。此函数分配由 newGuid() 函数生成的值，并返回更新后的 JSON 对象：

setProperty(json('customerProfile'), 'accountNumber', newGuid())

skip

删除集合开头的项，并返回所有其他项。

skip([<collection>], <count>)

参数	必选	类型	说明
<collection>	是	数组	要删除其项的集合
<count>	是	integer	要从开头删除的项数（一个正整数）

返回值	类型	说明
<updatedCollection>	数组	删除指定项后得到的更新后的集合

示例

此示例从指定数组的开头删除一个项（数字 1）：

skip(createArray(0, 1, 2, 3), 1)

并返回包含剩余项 ([1,2,3]) 的数组。

sortBy

按升序对集合中的元素进行排序，然后返回排序后的集合。

sortBy([<collection>], '<property>')

参数	必选	类型	说明
<collection>	是	字符串或数组	要排序的集合
<property>	否	string	如果设置，则按集合中对象元素的此特定属性排序

返回值	类型	描述
<new-collection>	数组	已对其元素进行排序的新集合

示例 1

此示例将对以下集合进行排序：

sortBy(createArray(1, 2, 0, 3))

并返回结果 [0, 1, 2, 3]。

示例 2

假设有以下集合：

{
  'nestedItems': [
    {'x': 2},
    {'x': 1},
    {'x': 3}
  ]
}

此示例基于 x 对象属性生成新的排序集合

sortBy(nestedItems, 'x')

并返回结果：

{
  'nestedItems': [
    {'x': 1},
    {'x': 2},
    {'x': 3}
  ]
}

sortByDescending

按降序对集合中的元素进行排序，然后返回排序后的集合。

sortBy([<collection>], '<property>')

参数	必选	类型	说明
<collection>	是	字符串或数组	要排序的集合
<property>	否	string	如果设置，则按集合中对象元素的此特定属性排序

返回值	类型	描述
<new-collection>	数组	已对其元素进行排序的新集合

示例 1

此示例生成新的排序集合：

sortByDescending(createArray(1, 2, 0, 3))

并返回结果 [3, 2, 1, 0]。

示例 2

假设有以下集合：

{
  'nestedItems': [
    {'x': 2},
    {'x': 1},
    {'x': 3}
  ]
}

此示例基于 x 对象属性生成新的排序集合：

sortByDescending(nestedItems, 'x')

并返回以下结果：

{
  'nestedItems': [
    {'x': 3},
    {'x': 2},
    {'x': 1}
  ]
}

split

根据原始字符串中指定的分隔符字符，返回一个包含子字符串（以逗号分隔）的数组。

split('<text>', '<delimiter>'?)

参数	必选	类型	说明
<text>	是	string	根据原始字符串中指定的分隔符将分隔成 substring 的字符串。如果文本为 NULL 值，则将其视为空字符串。
<delimiter>	否	string	原始字符串中用作分隔符的字符。如果未提供分隔符或者分隔符为 Null 值，则默认值将为空字符串。

返回值	类型	说明
[<substring1>,<substring2>,...]	array	一个数组，其中包含从原始字符串返回以逗号分隔的子字符串

示例

这些示例根据指定的分隔符字符，从指定字符串创建具有 substring 的数组：

split('a**b**c', '**')
split('hello', '')
split('', 'e')
split('', '')
split('hello')

并分别返回以下数组作为结果：

["a", "b", "c"]
["h", "e", "l", "l", "o"]
["h", "e", "l", "l", "o"]

sqrt

返回指定数字的平方根。

sqrt(<number>)

参数	必选	类型	说明
<number>	是	number	要获取其平方根的数字

返回值	类型	说明
<result>	number	计算平方根的结果。

示例

以下示例计算指定数字的平方根：

sqrt(9)
sqrt(0)

并分别返回下列结果：

startOfDay

以可选区域设置格式返回时间戳的开始日期。

startOfDay('<timestamp>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	描述
'<updated-timestamp>'	string	从当天的零小时标记开始的指定时间戳

示例 1

此示例查找当天的开始时间：

startOfDay('2018-03-15T13:30:30.000Z')

并返回结果 2018-03-15T00:00:00.000Z。

示例 2

此示例使用区域设置 fr-FR 查找一天的开始时间：

startOfDay('2018-03-15T13:30:30.000Z', '', 'fr-FR')

并返回结果15/03/2018 00:00:00.。

startOfHour

以可选区域设置格式返回时间戳的小时开始时间。

startOfHour('<timestamp>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	描述
'<updated-timestamp>'	string	从当天的零分钟标记开始的指定时间戳

示例 1

此示例查找小时的开始时间：

startOfHour('2018-03-15T13:30:30.000Z')

并返回结果 2018-03-15T13:00:00.000Z。

示例 2

此示例使用区域设置 fr-FR 查找小时开始的时间：

startOfHour('2018-03-15T13:30:30.000Z', '', 'fr-FR')

并返回结果 15/03/2018 13:00:00。

startOfMonth

以可选的区域设置格式返回时间戳中的月份的开始时间。

startOfMonth('<timestamp>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	描述
'<updated-timestamp>'	string	从当月第一天的零小时标记开始的指定时间戳

示例 1

此示例查找当月的开始时间：

startOfMonth('2018-03-15T13:30:30.000Z')

并返回结果 2018-03-01T00:00:00.000Z。

示例 2

此示例用区域设置fr-FR查找当月的开始时间：

startOfMonth('2018-03-15T13:30:30.000Z', '', 'fr-FR')

并返回结果 01/03/2018 00:00:00。

startsWith

检查字符串是否以特定的子字符串开头。如果找到 substring，返回 true；否则返回 false。此函数区分大小写。

startsWith('<text>', '<searchText>')

参数	必选	类型	说明
<text>	是	string	要检查的字符串
<searchText>	是	string	要查找的起始 substring

返回值	类型	说明
true 或 false	布尔	如果找到起始 substring，则返回 `true`。如果找不到结尾 substring，则返回 `false`

示例 1

此示例检查字符串“hello world”是否以字符串“hello”开头：

startsWith('hello world', 'hello')

并返回结果 true。

示例 2

此示例检查字符串“hello world”是否以字符串“greeting”开头：

startsWith('hello world', 'greeting')

并返回结果 false。

string

以可选区域设置格式返回值的字符串版本。

string(<value>, '<locale>'?)

参数	必选	类型	说明
<value>	是	any	要转换的值
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<string-value>	string	指定值的字符串版本

示例 1

此示例创建数字 10 的字符串版本：

string(10)

返回字符串结果 10。

示例 2

此示例为指定的 JSON 对象创建字符串并使用反斜杠字符 () 作为双引号 (") 字符的转义字符\\。

string( { "name": "Sophie Owen" } )

并返回结果 { "name": "Sophie Owen" }

示例 3

以下示例在特定区域设置中创建数字 10 的字符串版本：

string(100.1, 'fr-FR')
string(100.1, 'en-US')

并分别返回以下字符串：

100,1
100.1

stringOrValue

包装字符串内插以获取实际值。例如， stringOrValue('${1}') 返回数字 1，同时 stringOrValue('${1} item') 返回字符串“1 项”。

stringOrValue(<string>)

参数	必选	类型	说明
<字符串>	是	string	要从中获取实际值的字符串。

返回值	类型	说明
<result>	any	获取指定字符串的实际值的结果。

示例

这些示例从字符串中获取实际值：

stringOrValue('${one}')
stringOrValue('${one} item')

并分别返回下列结果：

数字 1.0。
字符串 1 项。

sub

返回第一个数字减去第二个数字得到的结果。

sub(<minuend>, <subtrahend>)

参数	必选	类型	说明
<minuend>	是	数字	要从中减去 subtrahend 的数字
<subtrahend>	是	数字	要从 minuend 中减去的数字

返回值	类型	说明
<result>	数字	第一个数字减去第二个数字得到的结果

示例

此示例从第一个数字中减去第二个数字：

sub(10.3, .3)

并返回结果 10。

subArray

从指定起始位置和结束位置返回子数组。索引值从数字 0 开始。

subArray(<Array>, <startIndex>, <endIndex>)

参数	必选	类型	说明
<array>	是	数组	用于创建子数组的数组
<startIndex>	是	integer	等于或大于 0 的正数用作起始位置或索引值
<endIndex>	是	integer	等于或大于 0 的正数用作结束位置或索引值

返回值	类型	描述
<subarray-result>	数组	包含指定项数的子数组，从源字符串中的指定索引位置开始

示例

此示例从指定的数组创建子数组：

subArray(createArray('H','e','l','l','o'), 2, 5)

并返回结果 ["l", "l", "o"]。

substring

返回字符串中的字符，从指定的位置或索引开始。索引值从数字 0 开始。

substring('<text>', <startIndex>, <length>)

参数	必选	类型	说明
<text>	是	string	用于创建 substring 的字符串
<startIndex>	是	integer	子数组的等于或大于 0 的正数用作起始位置或索引值
<length>	是	integer	substring 中的正数字符子数组

返回值	类型	说明
<substring-result>	string	包含指定字符数的子字符串，从源字符串中的指定索引位置开始

示例

此示例基于指定的字符串从索引值 6 开始创建一个五字符的子字符串：

substring('hello world', 6, 5)

并返回结果“world”。

subtractFromTime

以可选的区域设置格式从时间戳中减去一定数目的时间单位。另请参阅 getPastTime()。

subtractFromTime('<timestamp>', <interval>, '<timeUnit>', '<format>'?, '<locale>'?)

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串
<间隔>	是	integer	要减去的指定时间单位数
<timeUnit>	是	string	间隔使用的时间单位。可能的单位为“秒”、“分钟”、“小时”、“天”、“周”、“月”。
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<updated-timestamp>	string	时间戳减去指定的时间单位数

示例 1

此示例从以下时间戳中减去 1 天：

subtractFromTime('2018-01-02T00:00.000Z', 1, 'Day')

并返回结果 2018-01-01T00:00:00.000Z。

示例 2

此示例使用 D 格式从以下时间戳中减去 1 天：

subtractFromTime('2018-01-02T00:00.000Z', 1, 'Day', 'D')

并返回结果 星期一，2018 年 1 月 1 日。

示例 3

此示例从 de-DE 区域设置中的时间戳减去 1 小时：

subtractFromTime('2018-03-15T13:00:00.000Z', 1, 'Hour', '', 'de-DE')

并返回结果 15.03.18 12:00:00。

sum

返回列表中两个数字相加的结果。

sum([<list of numbers>])

参数	必选	类型	描述
[<list of numbers>]	是	数字数组	要相加的数字

返回值	类型	说明
<result-sum>	number	指定数字相加的结果

示例

此示例将指定的数字相加：

sum(createArray(1, 1.5))

并返回结果 2.5。

take

返回集合开头的项。

take('<collection>', <count>)
take([<collection>], <count>)

参数	必选	类型	说明
<collection>	是	字符串或数组	所需项所在的集合
<count>	是	integer	从开头算起所需的项数（一个正整数）

返回值	类型	说明
<subset> 或 [<subset>]	分别为字符串或数组	一个字符串或数组，其中包含来自原始集合开头的指定数目的项

示例

这些示例从以下集合的开头获取指定的项数：

take('abcde', 3)
take(createArray(0, 1, 2, 3, 4), 3)

并分别返回下列结果：

abc
[0, 1, 2]

ticks

返回指定时间戳的时钟周期属性值。一个时钟周期是 100 纳秒时间间隔。

ticks('<timestamp>')

参数	必选	类型	说明
<timestamp>	是	string	时间戳的字符串

返回值	类型	说明
<ticks-number>	integer（Javascript 中的 bigint）	从指定的时间戳算起已过去的时钟周期数

示例

该示例将时间戳转换为其时钟周期属性：

ticks('2018-01-01T08:00:00.000Z')

并返回结果 636503904000000000。

ticksToDays

将刻度属性值转换为天数。

ticksToDays('ticks')

参数	必选	类型	描述
<ticks>	是	integer	要转换的 ticks 属性值

返回值	类型	描述
<天数>	number	从刻度属性值转换的天数

示例

此示例将刻度属性值转换为天数：

ticksToDays(2193385800000000)

并返回数字 2538.64097222。

ticksToHours

将刻度属性值转换为小时数。

ticksToHours('ticks')

参数	必选	类型	描述
<ticks>	是	整数	要转换的 ticks 属性值

返回值	类型	描述
<number-of-hours>	数字	从刻度属性值转换的小时数

示例

此示例将刻度属性值转换为小时数：

ticksToHours(2193385800000000)

并返回数字 60927.383333333331。

ticksToMinutes

将刻度属性值转换为分钟数。

ticksToMinutes('ticks')

参数	必选	类型	描述
<ticks>	是	integer	要转换的 ticks 属性值

返回值	类型	描述
<number-of-minutes>	数字	从刻度属性值转换的分钟数

示例

此示例将刻度属性值转换为分钟数：

ticksToMinutes(2193385800000000)

并返回数字 3655643.0185。

titleCase

以可选区域设置格式将字符串中每个单词的第一个字母大写。

titleCase('<text>', '<locale>'?)

参数	必选	类型	说明
<text>	是	string	原始字符串
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	描述
结果字符串	string	标题事例结果

示例 1

这些示例将字符串中每个单词的第一个字母大写：

titleCase('a')
titleCase('abc def')
titleCase('aBC dEF')

并分别返回下列结果：

A
Abc Def
Abc Def

示例 2

这些示例将字符串中的第一个字母以 en-US 格式大写：

titleCase('a', 'en-US')
titleCase('aBC dEF', 'en-US')

并分别返回下列结果：

A
Abc Def

toLower

以可选区域设置格式返回小写字符串。如果字符串中的某个字符没有对应的小写版本，则该字符在返回的字符串中保持原样。

toLower('<text>', '<locale>'?)

参数	必选	类型	说明
<text>	是	string	要以小写格式返回的字符串
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<lowercase-text>	string	采用小写格式的原始字符串

示例 1

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

toLower('Hello World')

并返回结果 hello world。

示例 2

此示例使用 fr-FR 格式将字符串转换为小写：

toUpper('Hello World', 'fr-FR')

并返回结果 hello world。

toUpper

以可选区域设置格式返回大写字符串。如果字符串中的某个字符没有对应的大写版本，则该字符在返回的字符串中保持原样。

toUpper('<text>', '<locale>'?)

参数	必选	类型	说明
<text>	是	string	要以大写格式返回的字符串
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<uppercase-text>	string	采用大写格式的原始字符串

示例 1

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

toUpper('Hello World')

并返回结果HELLO WORLD。

示例 2

此示例使用 fr-FR 格式将字符串转换为大写：

toUpper('Hello World', 'fr-FR')

并返回结果HELLO WORLD。

trim

从字符串中删除前导和尾随空格，并返回更新后的字符串。

trim('<text>')

参数	必选	类型	说明
<text>	是	string	包含要删除的前导和尾随空格的字符串

返回值	类型	说明
<updatedText>	string	原始字符串的更新后版本，其中不含前导或尾随空格

示例

此示例从字符串 " Hello World " 中删除前导空格和尾随空格：

trim(' Hello World  ')

并返回删减后的结果“Hello World”。

union

返回一个集合，其中包含指定集合中的所有项。某个项只要出现在传递给此函数的任一集合中便会出现在结果中。如果一个或多个项具有相同的名称，则具有该名称的最后一项将出现在结果中。

union('<collection1>', '<collection2>', ...)
union([<collection1>], [<collection2>], ...)

参数	必选	类型	说明
<collection1>, <collection2>, ...	是	数组或对象，但不能同时为两者	需要从中获取所有项的各个集合

返回值	类型	说明
<updatedCollection>	分别为数组或对象	一个集合，其中包含指定集合中的所有项。未添加重复项。

示例

本示例获取以下集合中的所有项：

union(createArray(1, 2, 3), createArray(1, 2, 10, 101))

并返回结果 [1, 2, 3, 10, 101]。

unique

从数组中删除所有重复项。

unique([<collection>])

参数	必选	类型	说明
<collection>	是	数组	要修改的集合

返回值	类型	描述
<new-collection>	array	删除了重复元素的新集合

示例 1

此示例从以下数组中删除重复的元素：

unique(createArray(1, 2, 1))

并返回结果 [1, 2]。

uriComponent

返回统一资源标识符 (URI) 组件的二进制版本。

uriComponent('<value>')

参数	必选	类型	说明
<value>	是	string	要转换为 URI 编码格式的字符串

返回值	类型	说明
<encoded-uri>	string	带有转义字符的 URI 编码字符串

示例

此示例创建字符串的 URI 编码版本：

uriComponent('https://contoso.com')

并返回结果 http%3A%2F%2Fcontoso.com。

uriComponentToString

返回统一资源标识符 (URI) 编码字符串的字符串版本，有效地对 URI 编码字符串进行解码。

uriComponentToString('<value>')

参数	必选	类型	说明
<value>	是	string	要解码的 URI 编码字符串

返回值	类型	说明
<binary-for-encoded-uri>	string	URI 编码字符串的解码后的版本

示例

此示例创建 URI 编码字符串的解码后字符串版本：

uriComponentToString('http%3A%2F%2Fcontoso.com')

并返回结果 https://contoso.com。

uriHost

返回统一资源标识符 (URI) 的主机值。

uriHost('<uri>')

参数	必选	类型	描述
<uri>	是	string	所需主机值的 URI

返回值	类型	说明
<host-value>	string	指定 URI 的主机值

示例

此示例查找以下 URI 的主机值：

uriHost('https://www.localhost.com:8080')

并返回结果 www.localhost.com。

uriPath

返回统一资源标识符 (URI) 的路径值。

uriPath('<uri>')

参数	必选	类型	描述
<uri>	是	string	所需路径值的 URI

返回值	类型	说明
<path-value>	string	指定 URI 的路径值

示例

此示例查找以下 URI 的路径值：

uriPath('http://www.contoso.com/catalog/shownew.htm?date=today')

并返回结果 /catalog/shownew.htm。

uriPathAndQuery

返回统一资源标识符 (URI) 的路径和查询值。

uriPathAndQuery('<uri>')

参数	必选	类型	描述
<uri>	是	string	所需路径和查询值的 URI

返回值	类型	说明
<path-query-value>	string	指定 URI 的路径和查询值

示例

此示例查找以下 URI 的路径和查询值：

uriPathAndQuery('http://www.contoso.com/catalog/shownew.htm?date=today')

并返回结果 /catalog/shownew.htm?date=today。

uriPort

返回统一资源标识符 (URI) 的端口值。

uriPort('<uri>')

参数	必选	类型	描述
<uri>	是	string	所需路径值的 URI

返回值	类型	说明
<port-value>	string	指定 URI 的端口值

示例

此示例查找以下 URI 的端口值：

uriPort('http://www.localhost:8080')

并返回结果 8080。

uriQuery

返回统一资源标识符 (URI) 的查询值。

uriQuery('<uri>')

参数	必选	类型	描述
<uri>	是	string	所需查询值的 URI

返回值	类型	说明
<query-value>	string	指定 URI 的查询值

示例

此示例查找以下 URI 的查询值：

uriQuery('http://www.contoso.com/catalog/shownew.htm?date=today')

并返回结果 ?date=today。

uriScheme

返回统一资源标识符 (URI) 的方案值。

uriScheme('<uri>')

参数	必选	类型	描述
<uri>	是	string	所需查询值的 URI

返回值	类型	说明
<scheme-value>	string	指定 URI 的方案值

示例

此示例查找以下 URI 的方案值：

uriQuery('http://www.contoso.com/catalog/shownew.htm?date=today')

并返回结果“http”。

utcNow

以可选区域设置格式返回字符串形式的当前时间戳。

utcNow('<format>', '<locale>'?)

另外，也可以使用 <format> 参数指定不同的格式。

参数	必选	类型	说明
<format>	否	string	自定义格式模式。时间戳的默认格式为 UTC ISO 格式，即 YYYY-MM-DDTHH:mm:ss.fffZ，这符合 ISO 8601。
<区域设置>	否	string	区域性信息的可选区域设置

返回值	类型	说明
<current-timestamp>	string	当前日期和时间

示例 1

假设日期是 2018 年 4 月 15 日下午 1:00:00。此示例获取时间戳：

utcNow()

并返回结果 2018-04-15T13:00:00.000Z。

示例 2

假设日期是 2018 年 4 月 15 日下午 1:00:00。此示例使用可选的“D”格式获取当前时间戳：

utcNow('D')

并返回结果“2018 年 4 月 15 日，星期天”。

示例 3

假设日期是 2018 年 4 月 15 日下午 1:00:00。此示例使用 de-DE 区域格式获取当前时间戳：

utcNow('', 'de-DE')

并返回结果15.04.18 13:00:00。

where

对每个元素进行筛选，然后返回与特定条件匹配的筛选后的新元素集合。

where([<collection/instance>], <iteratorName>, <function>)

参数	必选	类型	描述
<collection/instance>	是	array	包含项的集合
<iteratorName>	是	迭代器名称	键项
<函数>	是	表达式	用于筛选项的条件函数

返回值	类型	描述
<new-collection/new-object>	数组/对象	一个新集合，其中每个元素都使用函数进行筛选

示例 1

此示例生成新的集合：

where(createArray(0, 1, 2, 3), x, x > 1)

并返回结果 [2, 3]。

示例 2

此示例生成新的集合：

where(json("{'name': 'jack', 'age': '15'}"), x, x.value == 'jack')
where(json("{'name': 'jack', 'age': '15'}"), x=> x.value == 'jack')

并返回结果 ['name:jack', 'age:15']。请注意，第二个表达式是 lambda 表达式，有些表达式会发现更易读。

xml

返回包含 JSON 对象的字符串的 XML 版本。

xml('<value>')

参数	必选	类型	说明
<value>	是	string	要转换的包含 JSON 对象的字符串。该 JSON 对象必须只有一个根属性，该属性不能是数组。请使用 \ 作为双引号 (") 的转义字符。

返回值	类型	说明
<xml-version>	object	指定的字符串或 JSON 对象的编码 XML

示例 1

此示例创建包含 JSON 对象的字符串的 XML 版本：

xml(json('{ \"name\": \"Sophia Owen\" }'))

并返回结果 XML：

<name>Sophia Owen</name>

示例 2

假设你有一个 person JSON 对象，如下所示：

{
  "person": {
    "name": "Sophia Owen",
    "city": "Seattle"
  }
}

此示例创建包含该 JSON 对象的字符串的 XML：

xml(json('{\"person\": {\"name\": \"Sophia Owen\", \"city\": \"Seattle\"}}'))

并返回结果 XML：

<person>
  <name>Sophia Owen</name>
  <city>Seattle</city>
<person

xPath

检查 XML 中是否存在与 XPath（XML 路径语言）表达式匹配的节点或值，并返回匹配的节点或值。 XPath 表达式（称为 XPath）可帮助你在 XML 文档结构中导航，以便可以在 XML 内容中选择节点或计算值。

xPath('<xml>', '<xpath>')

参数	必选	类型	说明
<xml>	是	any	要在其中搜索与 XPath 表达式值匹配的节点或值的 XML 字符串
<xPath>	是	any	用来查找匹配的 XML 节点或值的 XPath 表达式

返回值	类型	说明
<xml-node>	XML	一个 XML 节点，当只有单个节点与指定的 XPath 表达式匹配时
<value>	any	来自一个 XML 节点的值，当只有单个值与指定的 XPath 表达式匹配时
<[<xml-node1>, <xml-node2>, ...] -or- [<value1>, <value2>, ...]>	array	一个数组，其中包含与指定的 XPath 表达式匹配的 XML 节点或值

示例 1

此示例查找与指定参数中的 <name></name> 节点匹配的节点，并返回包含这些节点值的数组：

xPath(items, '/produce/item/name')

参数包含“items”字符串，其中包含以下 XML：

"<?xml version="1.0"?> <produce> <item> <name>Gala</name> <type>apple</type> <count>20</count> </item> <item> <name>Honeycrisp</name> <type>apple</type> <count>10</count> </item> </produce>"

下面是生成的数组，其中包含与 <name></name> 匹配的节点：

[ <name>Gala</name>, <name>Honeycrisp</name> ]

示例 2

依据示例 1，此示例查找与 <count></count> 节点匹配的节点并通过 sum() 函数添加这些节点值：

xPath(xml(parameters('items')), 'sum(/produce/item/count)')

并返回结果 30。

year

返回指定时间戳的年份。

year('<timestamp>')

参数	必选	类型	说明
<timestamp>	是	string	包含时间戳的字符串

返回值	类型	描述
<year>	integer	指定时间戳的年份

示例

此示例计算年份的时间戳：

year('2018-03-15T00:00:00.000Z')

并返回结果 2018。