自适应表达式预生成函数

适用于： SDK v4

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

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

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

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

返回指定数字的绝对值。

abs(<number>)

示例

这些示例计算绝对值：

abs(3.12134)
abs(-3.12134)

两者都返回结果 3.12134。

返回添加两个或多个数字（纯数字大小写）或连接两个或多个字符串（其他大小写）的结果。

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

示例

此示例添加指定的数字：

add(1, 1.5)

并返回结果 2.5。

此示例连接指定的项：

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

并返回结果

• hello
• helloworld

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

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

示例 1

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

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

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

示例 2

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

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('<timestamp>', <hours>, '<format>'?, '<locale>'?)

示例 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

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

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

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

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

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

示例 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

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

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

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

返回输入编号的序号。

addOrdinal(<number>)

示例

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

并分别返回以下结果：

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

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

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

示例

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

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

将秒数添加到时间戳。

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

示例 1

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

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

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

示例 2

此示例将五秒减去指定的时间戳：

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

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

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

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

示例 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-DD-YY”格式返回为 01-15-18。

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

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

示例

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

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

并分别返回以下结果：

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

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

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

示例 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。

确定序列的任何元素是否满足条件。

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

示例

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

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

并分别返回以下结果：

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

返回数值数组的数字平均值。

average(<numericArray>)

示例

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

average(createArray(1,2,3))

并返回结果 2。

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

base64('<value>')

示例 1

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

base64('hello')

并返回结果 “aGVsbG8=”。

示例 2

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

base64('byteArr')

返回结果 “AwUBDA==”。

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

base64ToBinary('<value>')

示例

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

base64ToBinary('AwUBDA==')

并返回结果 新的字节[] { 3， 5， 1， 12 }。

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

base64ToString('<value>')

示例

此示例将 base64 编码的字符串 aGVsbG8= 转换为解码的字符串：

base64ToString('aGVsbG8=')

并返回 hello 的结果。

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

binary('<value>')

示例

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

binary('hello')

返回结果 新的字节[] { 104， 101， 108， 108， 111 }。

返回值的布尔版本。

bool(<value>)

示例

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

bool(1)
bool(0)

并分别返回以下结果：

• true
• false

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

ceiling('<number>')

示例

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

ceiling(10.333)

并返回整数 11。

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

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

示例

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

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

分别返回：

• true
• hello
• 零

合并两个或多个对象，并在列表或字符串中返回合并的对象。

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

预期返回值：

• 如果所有项都是列表，则返回一个列表。
• 如果存在不是列表的项，将返回一个字符串。
• 如果值为 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。

检查集合是否具有特定项。 如果找到该项，则返回 true;如果未找到，则返回 false。 此函数区分大小写。

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

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

• 用于查找子字符串的字符串
• 用于查找值的数组
• 用于查找键的字典

示例 1

此示例检查子字符串 世界的字符串 hello world：

contains('hello world', 'world')

并返回结果 true。

示例 2

此示例检查子字符串 宇宙的字符串 hello world：

contains('hello world', 'universe')

并返回结果 false。

返回集合中的项数。

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

示例：

这些示例计算这些集合中的项数：

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

两者都返回结果 4。

返回字符串中的单词数

countWord('<text>')

示例

本示例计算字符串中单词数，hello world：

countWord("hello word")

它返回结果 2。

将采用可选区域设置格式的时间戳从世界时协调（UTC）转换为目标时区。

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

示例：

以下示例从 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 日星期一。

将采用可选区域设置格式的时间戳从源时区转换为世界时协调（UTC）。

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

示例

此示例将时间戳从太平洋标准时间转换为 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('<object1>', '<object2>', ...)

示例

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

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

返回结果 [h，e， l， l， l， o]。

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

dataUri('<value>')

示例

dataUri('hello')

返回数据：text/plain; 结果;charset=utf-8;base64，aGVsbG8=。

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

dataUriToBinary('<value>')

示例

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

dataUriToBinary('aGVsbG8=')

返回结果 新的字节[] { 97， 71， 86， 115， 98， 71， 56， 61 }。

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

dataUriToString('<value>')

示例

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

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

并返回 hello 的结果。

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

date('<timestramp>')

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

返回结果 3-15-2018。

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

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

示例 1

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

返回明天 的结果。

返回两个时间戳之间的刻度差异。

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

示例 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')

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

返回时间戳中的月份日期。

dayOfMonth('<timestamp>')

示例

此示例返回以下时间戳中月份日期的数字：

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

并返回结果 15。

从时间戳返回一周中的一天。

dayOfWeek('<timestamp>')

示例

此示例返回以下时间戳中星期几的数字：

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

并返回结果 3。

从时间戳返回一年中的一天。

dayOfYear('<timestamp>')

示例

本示例从以下时间戳返回一年中的一天数：

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

并返回结果 74。

返回除以两个数字的整数结果。 若要返回余数，请参阅 mod（）。

div(<dividend>, <divisor>)

示例

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

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

并返回结果 2。

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

如果其中一个参数是 float，则结果也将是带有 .NET SDK 的 FLOAT。

示例

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))))

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

• 输入为 null 或未定义
• 输入为 null 或空字符串
• 输入为零大小集合
• input 是一个没有属性的对象。

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

示例

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

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

并分别返回以下结果：

• 传递空字符串，因此函数返回 true。
• abc传递字符串，因此函数返回 false。
• 传递包含一项的集合，因此函数返回 false。
• 传递 null 对象，因此函数返回 true。

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

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

示例 1

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

endsWith('hello world', 'world')

它返回结果 true。

示例 2

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

endsWith('hello world', 'universe')

它返回结果 false。

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

EOL()

示例

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

EOL()

并返回以下字符串：

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

检查两个值、表达式还是对象是否等效。 如果两者都等效，则返回 true;如果两者都不等效，则返回 false。

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

示例

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

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

并分别返回以下结果：

• 这两个值都是等效的，因此函数返回 true。
• 这两个值都不相等，因此函数返回 false。

计算真实情况的表达式。

exists(expression)

示例

以下示例评估 foo = {"bar":"value"}的真实性：

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

并分别返回以下结果：

• true
• false

将一个数字的指数返回到另一个数字。

exp(realNumber, exponentNumber)

示例

此示例计算指数：

exp(2, 2)

并返回结果 4。

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

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

示例

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

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

并分别返回以下结果：

• h
• 0

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

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

示例 1

THis 示例平展以下数组：

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>')

示例

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

float('10.333')

并返回 float 10.333。

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

floor('<number>')

示例

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

floor(10.333)

并返回整数 10。

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

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

示例 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('<timestamp>', '<format>'?, '<locale>'?)

示例 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。

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

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

示例

此示例将 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('<number>', '<precision-digits>', '<locale>'?)

示例 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('<ticks>', '<format>'?, '<locale>'?)

示例 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(<interval>, <timeUnit>, '<format>'?, '<locale>'?)

示例 1

假设当前时间戳 2019-03-01T00：00：00.000Z。 以下示例向该时间戳添加五天：

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.00.000Z，区域设置 de-DE。 以下示例将 1 天添加到时间戳：

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

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

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

getNextViableDate(<timexString>, <timezone>?)

示例

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

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

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

并分别返回以下字符串：

• 2020-12-20
• 2024-02-29

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

getNextViableTime(<timexString>, <timezone>?)

示例

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

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

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

并分别返回以下字符串：

• T16：12：14
• T15：52：14

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

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

示例 1

假设当前时间戳 2018-02-01T00：00：00.000Z。 此示例从该时间戳中减去五天：

getPastTime(5, 'Day')

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

示例 2

假设当前时间戳 2018-03-01T00：00：00.000Z。 此示例将 5 天减去 MM-DD-YY 格式的时间戳：

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

并返回结果 02-26-18。

示例 3

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

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

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

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

getPreviousViableDate(<timexString>, <timezone>?)

示例

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

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

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

并分别返回以下字符串：

• 2019-12-20
• 2020-02-29

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

getPreviousViableTime(<timexString>, <timezone>?)

示例

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

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

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

并分别返回以下字符串：

• T14：52：14
• T15：12：14

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

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

示例

假设具有以下 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>')

示例

假设具有以下 JSON 对象：

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

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

getProperty("a:b")

并返回 a：b 值 字符串。

返回给定时间戳的一天时间。

getTimeOfDay('<timestamp>')

返回的时间是以下字符串之一：

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

示例

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

返回 早的结果。

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

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

示例

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

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

并分别返回以下结果：

• true
• false

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

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

示例

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

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

并分别返回以下结果：

• true
• false

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

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

示例

此示例评估 equals(1,1) 是否为 true：

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

返回 是，因为指定的表达式返回 true。 否则，该示例返回 无。

返回子字符串的起始位置或索引值。 此函数不区分大小写，索引以数字 0 开头。

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

示例 1

本示例查找字符串 世界 字符串的起始索引值，hello world：

indexOf('hello world', 'world')

并返回结果 6。

示例 2

本示例在数组 ['abc'， 'def'， 'ghi']中查找子字符串 的起始索引值：

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

并返回结果 1。

将数组或对象转换为具有索引（当前索引）和值属性的对象数组。 对于数组，索引是数组中的位置。 对于对象，它是值的键。

indicesAndValues('<collection or object>')

示例 1

假设你有一个列表 { 项： [“zero”， “one”， “two”] }。 以下函数采用该列表：

indicesAndValues(items)

并返回一个新列表：

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

示例 2

假设你有一个列表 { 项： [“zero”， “one”， “two”] }。 以下函数采用该列表：

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

并返回一个新列表：

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

示例 3

假设你有一个列表 { 项： [“zero”， “one”， “two”] }。 以下函数采用该列表：

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

并返回结果 零，一，两。 此表达式的效果与 join（items， '，''）相同。

示例 4

假设你有一个对象 { user： {name： 'jack'， age： 20} }。 以下函数采用该对象：

indicesAndValues(user)

并返回一个新对象：

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

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

int('<value>')

示例

此示例为字符串创建一个整数版本，10：

int('10')

并将结果作为整数 10返回。

返回一个集合，该集合中只有指定集合中的常用项。 若要显示在结果中，必须将项显示在传递给此函数的所有集合中。 如果一个或多个项具有相同的名称，则结果中会显示具有该名称的最后一项。

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

示例

此示例查找以下数组中的常见项：

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

返回一个数组，其中仅 [1， 2]项。

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

isArray('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 false。
• 输入是一个数组，因此函数返回 true。

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

isBoolean('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 false。
• 输入为布尔值，因此函数返回 true。

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

isDate('<input>')

示例

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

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

并返回以下结果：

• false
• true

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

isDateRange('<input>')

示例

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

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

并返回以下结果：

• false
• true

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

isDateTime('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 false。
• 输入是 UTC ISO 格式字符串，因此函数返回 true。

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

isDefinite('<input>')

示例

假设有一个 TimexProperty 对象 validFullDate = new TimexProperty（“2020-02-20”），Now 属性设置为 true。 以下示例检查对象是否引用了有效的完整日期：

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

并分别返回以下结果：

• false
• true

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

isDuration('<input>')

示例

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

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

并分别返回以下结果：

• true
• false

如果给定输入是浮点数，则返回 true。 由于 C#和 JavaScript 之间的对齐方式，其模数 1 的非零残渣的数字将被视为浮点数。

isFloat('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 false。
• 输入的模式等于 0，因此函数返回 false。
• 输入是浮点数，因此函数返回 true。

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

isInteger('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 false。
• 输入的模式等于 0，因此函数返回 true。
• 输入是一个整数，因此函数返回 true。

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

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

示例

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

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

并返回相同的结果 true。

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

isObject('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 false。
• 输入是一个对象，因此函数返回 true。

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

isPresent('<input>')

示例 假设我们有一个 TimexProperty 对象 validNow = new TimexProperty（） { Now = true } 并将 Now 属性设置为 true。 以下示例检查以下输入是否引用了当前内容：

isPresent('PT30M')
isPresent(validNow)

并分别返回以下结果：

• false
• true

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

isString('<input>')

示例

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

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

并分别返回以下结果：

• 输入是一个字符串，因此函数返回 true。
• 输入为浮点数，因此函数返回 false。

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

isTime('<input>')

示例

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

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

并分别返回以下结果：

• false
• true

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

isTime('<input>')

示例

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

isTimeRange('PT30M')
isTimeRange(validTimeRange)

并分别返回以下结果：

• false
• true

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

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

示例

此示例使用指定字符 从此数组中的所有项创建字符串。作为分隔符：

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

并返回 a.b.c 结果。

检查 JSON 或 JSON 字符串中是否存在与路径表达式匹配的节点或值，并返回匹配的节点。

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

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
                }
            ]
        }
    ]
}

路径表达式 $.。产品[？（@.价格 >= 50]。名称

jPath(jsonStr, path)

它返回结果 [“Anvil”， “肘部脂”]。

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 \ “本田”&& .year > 2009}.model。

jPath(jsonStr, path)

它返回结果 ['Jazz'， 'Accord']。

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

json('<value>')

示例 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"
      } ]
   }
}

返回值的 JSON 字符串。

示例

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

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

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

• null
• {“a”：“b”}

从集合中返回最后一项。

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

示例

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

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

并分别返回以下结果：

• d
• 3

返回子字符串最后一个匹配项的起始位置或索引值。 此函数不区分大小写，索引以数字 0 开头。

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

示例 1

本示例查找 hello world 字符串中子字符串 world 的最后一个匹配项的起始索引值：

lastIndexOf('hello world', 'world')

并返回结果 6。

示例 2

本示例查找数组中最后出现的子字符串 def 的起始索引值，['abc'， 'def'， 'ghi'， 'def']。

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

并返回结果 3。

返回字符串的长度。

length('<str>')

示例

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

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

并分别返回以下结果：

• 5
• 11

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

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

示例

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

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

并分别返回以下结果：

• true
• false

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

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

示例

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

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

并分别返回以下结果：

• true
• false

返回列表或数组中的最大值。 列表或数组在两端都是非独占的。

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

示例

这些示例从数字集和数组中获取最高值：

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

并返回结果 3。

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

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

示例

假设具有以下 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(<number1>, <number2>, ...)
min([<number1>, <number2>, ...])

示例

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

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

并返回结果 1。

返回除以两个数字的余数。 若要获取整数结果，请参阅 div（）。

mod(<dividend>, <divisor>)

示例

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

mod(3, 2)

并返回结果 1。

返回指定时间戳的月份。

month('<timestamp>')

示例

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

它返回结果 3。

返回乘以两个数字的产品。

mul(<multiplicand1>, <multiplicand2>)

示例

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

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

并分别返回以下结果：

• 2
• 3

返回新的 Guid 字符串。

newGuid()

示例

newGuid()

它返回一个结果，它遵循格式 xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxx。

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

not(<expression>)

示例 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>, ...)

示例 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(<minValue>, <maxValue>)

示例

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

rand(1, 5)

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

返回从指定整数开始的整数数组。

range(<startIndex>, <count>)

示例

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

range(1, 4)

返回结果 [1， 2， 3， 4]。

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

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

示例

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

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

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

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

示例 1

此示例查找旧字符串 旧 中的子字符串，并将 旧 替换为 新的：

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

结果是新字符串 字符串。

示例 2

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

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

并分别返回以下结果：

• hello\n
• hello\\
• @“hello\\”
• @“hello\\”

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

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

示例

此示例查找字符串中的子字符串 旧旧字符串，并将 旧 替换为 新：

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

并返回新字符串 结果。

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

resolve('<timestamp')

示例

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

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

并分别返回以下结果：

• 14：00：00
• 2020-12-20
• 2020-12-20 14：20：00

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

reverse(<value>)

示例

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

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

并分别返回以下值：

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

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

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

示例 1

此示例将数字舍入 为 10.33310.333：

round(10.333)

并返回数字 10。

示例 2

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

round(10.3313, 2)

返回 10.33的数字。

对每个元素进行作，并返回已转换元素的新集合。

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