自适应表达式预生成函数

适用于： SDK v4

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

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

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

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

字符串函数

集合函数

逻辑比较函数

转换函数

数学函数

日期和时间函数

Timex 函数

URI 分析函数

对象操作和构造函数

正则表达式函数

类型检查函数

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

abs

返回指定数字的绝对值。

abs(<number>)

示例

这些示例计算绝对值：

abs(3.12134)
abs(-3.12134)

两者都返回结果 3.12134。

add

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

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

示例

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

add(1, 1.5)

并返回结果 2.5。

此示例连接指定项：

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

然后返回结果

• hello
• helloworld

addDays

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

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

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

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

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

示例

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

并分别返回以下结果：

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

addProperty

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

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

示例

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

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

addSeconds

将秒数加到时间戳。

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

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

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

示例

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

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。

any

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

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

示例

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

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

并分别返回下列结果：

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

average

返回数值阵列的数均。

average(<numericArray>)

示例

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

average(createArray(1,2,3))

并返回结果 2。

base64

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

base64('<value>')

示例 1

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

base64('hello')

并返回结果“aGVsbG8=”。

示例 2

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

base64('byteArr')

并返回结果“AwUBDA==”。

base64ToBinary

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

base64ToBinary('<value>')

示例

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

base64ToBinary('AwUBDA==')

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

base64ToString

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

base64ToString('<value>')

示例

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

base64ToString('aGVsbG8=')

并返回结果“hello”。

binary

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

binary('<value>')

示例

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

binary('hello')

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

bool

返回值的布尔版本。

bool(<value>)

示例

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

bool(1)
bool(0)

并分别返回以下结果：

• true
• false

ceiling

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

ceiling('<number>')

示例

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

ceiling(10.333)

并返回整数 11。

coalesce

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

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

示例

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

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

分别返回：

• true
• hello
• null

concat

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

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。

contains

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

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

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

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

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

示例：

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

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

两者都返回结果 4。

countWord

返回字符串中的单词数

countWord('<text>')

示例

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

countWord("hello word")

它返回结果 2。

convertFromUTC

以可选的区域设置格式将时间戳从协调世界时 (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 日。

convertToUTC

以可选的区域设置格式将时间戳从源时区转换为协调世界时 (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

从多个输入返回数组。

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

示例

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

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

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

dataUri

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

dataUri('<value>')

示例

dataUri('hello')

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

dataUriToBinary

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

dataUriToBinary('<value>')

示例

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

dataUriToBinary('aGVsbG8=')

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

dataUriToString

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

dataUriToString('<value>')

示例

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

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

并返回结果“hello”。

date

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

date('<timestramp>')

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

返回结果 3-15-2018。

dateReadBack

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

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

示例 1

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

返回结果“明天”。

dateTimeDiff

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

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

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

dayOfMonth

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

dayOfMonth('<timestamp>')

示例

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

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

并返回结果 15。

dayOfWeek

基于时间戳返回周几。

dayOfWeek('<timestamp>')

示例

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

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

并返回结果 3。

dayOfYear

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

dayOfYear('<timestamp>')

示例

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

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

并返回结果 74。

div

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

div(<dividend>, <divisor>)

示例

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

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

示例

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

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

并分别返回以下结果：

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

endsWith

检查字符串是否以特定的子字符串结尾。 如果找到 substring，返回 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()

示例

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

EOL()

并返回以下字符串：

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

等于

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

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

示例

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

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

并分别返回以下结果：

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

exists

计算表达式的真假性。

exists(expression)

示例

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

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

并分别返回以下结果：

• true
• false

exp

返回 n 的 m 次幂。

exp(realNumber, exponentNumber)

示例

此示例计算指数：

exp(2, 2)

并返回结果 4。

first

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

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

示例

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

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

并分别返回以下结果：

• h
• 0

平展 (flatten)

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

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

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

示例

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

float('10.333')

并返回浮点 10.333。

floor

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

floor('<number>')

示例

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

floor(10.333)

返回整数 10。

foreach

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

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

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

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。

formatEpoch

以可选的区域设置格式从 UNIX 时间（也称为 Epoch 时间、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

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

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

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

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

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

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

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

示例

假设日期为 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>?)

示例

假设日期为 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>'?)

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

示例

假设日期为 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>?)

示例

假设日期为 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>')

示例

假设你拥有以下 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

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

getTimeOfDay('<timestamp>')

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

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

示例

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

返回结果“上午”。

greater

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

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

示例

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

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

并分别返回下列结果：

• true
• false

greaterOrEquals

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

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

示例

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

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

并分别返回下列结果：

• true
• false

if

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

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

示例

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

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

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

indexOf

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

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

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

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

示例

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

int('10')

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

intersection

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

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

示例

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

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

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

isArray

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

isArray('<input>')

示例

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

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

并分别返回下列结果：

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

isBoolean

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

isBoolean('<input>')

示例

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

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

并分别返回下列结果：

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

isDate

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

isDate('<input>')

示例

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

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

并返回以下结果：

• false
• true

isDateRange

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

isDateRange('<input>')

示例

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

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

并返回以下结果：

• false
• true

isDateTime

如果给定输入是 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。

isDefinite

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

isDefinite('<input>')

示例

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

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

并分别返回下列结果：

• false
• true

isDuration

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

isDuration('<input>')

示例

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

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

并分别返回下列结果：

• true
• false

isFloat

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

isFloat('<input>')

示例

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

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

并分别返回下列结果：

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

isInteger

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

isInteger('<input>')

示例

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

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

并分别返回下列结果：

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

isMatch

如果给定的字符串与指定的正则表达式模式匹配，则返回 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。

isObject

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

isObject('<input>')

示例

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

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

并分别返回下列结果：

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

isPresent

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

isPresent('<input>')

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

isPresent('PT30M')
isPresent(validNow)

并分别返回下列结果：

• false
• true

isString

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

isString('<input>')

示例

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

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

并分别返回下列结果：

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

isTime

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

isTime('<input>')

示例

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

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

并分别返回下列结果：

• false
• true

isTimeRange

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

isTime('<input>')

示例

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

isTimeRange('PT30M')
isTimeRange(validTimeRange)

并分别返回下列结果：

• false
• true

join

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

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

示例

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

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

并返回结果 a.b.c。

jPath

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

路径表达式为 $..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>')

示例 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 字符串。

示例

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

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

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

• null
• {"a":"b"}

last

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

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

示例

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

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

并分别返回下列结果：

• d
• 3

lastIndexOf

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

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

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

示例

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

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

并分别返回下列结果：

• 5
• 11

less

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

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

示例

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

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

并分别返回下列结果：

• true
• false

lessOrEquals

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

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

示例

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

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

并分别返回下列结果：

• true
• false

max

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

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

示例

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

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

并返回结果 3。

merge

将多个 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

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

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

示例

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

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

并返回结果 1。

mod

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

mod(<dividend>, <divisor>)

示例

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

mod(3, 2)

并返回结果 1。

月

返回指定时间戳的月份。

month('<timestamp>')

示例

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

它返回结果 3。

mul

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

mul(<multiplicand1>, <multiplicand2>)

示例

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

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

并分别返回下列结果：

• 2
• 3

newGuid

返回新的 Guid 字符串。

newGuid()

示例

newGuid()

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

not

检查表达式是否为 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

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

rand(<minValue>, <maxValue>)

示例

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

rand(1, 5)

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

range

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

range(<startIndex>, <count>)

示例

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

range(1, 4)

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

removeProperty

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

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

示例

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

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

replace

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

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

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

示例

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

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

并返回结果“the new string”。

resolve

如果给定 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

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

reverse(<value>)

示例

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

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

并分别返回以下值：

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

round

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

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

示例 1

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

round(10.333)

并返回数字 10。

示例 2

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

round(10.3313, 2)

并返回数字 10.33。

SELECT…

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

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

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

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

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

示例

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

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

skip

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

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

示例

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

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

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

sortBy

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

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

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

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

示例

这些示例根据指定的分隔符字符，从指定字符串创建具有 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>)

示例

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

sqrt(9)
sqrt(0)

并分别返回下列结果：

• 3
• 0

startOfDay

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

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

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

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

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

示例 1

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

startsWith('hello world', 'hello')

并返回结果 true。

示例 2

此示例检查字符串“hello world”是否以字符串“greeting”开头：

startsWith('hello world', 'greeting')

并返回结果 false。

string

以可选区域设置格式返回值的字符串版本。

string(<value>, '<locale>'?)

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

示例

这些示例从字符串中获取实际值：

stringOrValue('${one}')
stringOrValue('${one} item')

并分别返回下列结果：

• 数字 1.0。
• 字符串 1 项。

sub

返回第一个数字减去第二个数字得到的结果。

sub(<minuend>, <subtrahend>)

示例

此示例从第一个数字中减去第二个数字：

sub(10.3, .3)

并返回结果 10。

subArray

从指定起始位置和结束位置返回子数组。 索引值从数字 0 开始。

subArray(<Array>, <startIndex>, <endIndex>)

示例

此示例从指定的数组创建子数组：

subArray(createArray('H','e','l','l','o'), 2, 5)

并返回结果 ["l", "l", "o"]。

substring

返回字符串中的字符，从指定的位置或索引开始。 索引值从数字 0 开始。

substring('<text>', <startIndex>, <length>)

示例

此示例基于指定的字符串从索引值 6 开始创建一个五字符的子字符串：

substring('hello world', 6, 5)

并返回结果“world”。

subtractFromTime

以可选的区域设置格式从时间戳中减去一定数目的时间单位。 另请参阅 getPastTime()。

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

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

示例

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

sum(createArray(1, 1.5))

并返回结果 2.5。

take

返回集合开头的项。

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

示例

这些示例从以下集合的开头获取指定的项数：

take('abcde', 3)
take(createArray(0, 1, 2, 3, 4), 3)

并分别返回下列结果：

• abc
• [0, 1, 2]

ticks

返回指定时间戳的时钟周期属性值。 一个时钟周期是 100 纳秒时间间隔。

ticks('<timestamp>')

示例

该示例将时间戳转换为其时钟周期属性：

ticks('2018-01-01T08:00:00.000Z')

并返回结果 636503904000000000。

ticksToDays

将刻度属性值转换为天数。

ticksToDays('ticks')

示例

此示例将刻度属性值转换为天数：

ticksToDays(2193385800000000)

并返回数字 2538.64097222。

ticksToHours

将刻度属性值转换为小时数。

ticksToHours('ticks')

示例

此示例将刻度属性值转换为小时数：

ticksToHours(2193385800000000)

并返回数字 60927.383333333331。

ticksToMinutes

将刻度属性值转换为分钟数。

ticksToMinutes('ticks')

示例

此示例将刻度属性值转换为分钟数：

ticksToMinutes(2193385800000000)

并返回数字 3655643.0185。

titleCase

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

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

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

示例 1

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

toLower('Hello World')

并返回结果 hello world。

示例 2

此示例使用 fr-FR 格式将字符串转换为小写：

toUpper('Hello World', 'fr-FR')

并返回结果 hello world。

toUpper

以可选区域设置格式返回大写字符串。 如果字符串中的某个字符没有对应的大写版本，则该字符在返回的字符串中保持原样。

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

示例 1

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

toUpper('Hello World')

并返回结果HELLO WORLD。

示例 2

此示例使用 fr-FR 格式将字符串转换为大写：

toUpper('Hello World', 'fr-FR')

并返回结果HELLO WORLD。

trim

从字符串中删除前导和尾随空格，并返回更新后的字符串。

trim('<text>')

示例

此示例从字符串 " Hello World " 中删除前导空格和尾随空格：

trim(' Hello World  ')

并返回删减后的结果“Hello World”。

union

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

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

示例

本示例获取以下集合中的所有项：

union(createArray(1, 2, 3), createArray(1, 2, 10, 101))

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

unique([<collection>])

unique(createArray(1, 2, 1))

uriComponent

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

uriComponent('<value>')

示例

此示例创建字符串的 URI 编码版本：

uriComponent('https://contoso.com')

并返回结果 http%3A%2F%2Fcontoso.com。

uriComponentToString

返回统一资源标识符 (URI) 编码字符串的字符串版本，有效地对 URI 编码字符串进行解码。

uriComponentToString('<value>')

示例

此示例创建 URI 编码字符串的解码后字符串版本：

uriComponentToString('http%3A%2F%2Fcontoso.com')