关于 Azure 逻辑应用和 Power Automate 中工作流表达式中的函数的参考指南

适用于：Azure 逻辑应用（消耗型 + 标准型）

对于 Azure 逻辑应用和 Power Automate 中的工作流定义，某些表达式从运行时操作中获取其值，而这些操作在工作流开始运行时可能尚不存在。 若要引用或处理这些表达式中的值，可以使用工作流定义语言提供的表达式函数。

例如，如果想要对整数或浮点数进行求和，可以使用数学函数（如 add() 函数）来计算值。 下面是可以使用函数执行的一些其他示例任务：

若要基于函数的常规用途查找函数，请查看以下各表。 若要了解每个函数的详细信息，请参阅按字母顺序排序的列表。

表达式中的函数

为了展示如何在表达式中使用函数，此示例展示了如何从 customerName 参数获取值，并在表达式中使用 accountName 函数将该值赋给 属性：

"accountName": "@parameters('customerName')"

下面是表达式中的函数的其他一般使用方法：

例如，concat() 函数可以采用两个或更多个字符串值作为参数。 此函数将这些字符串组合成一个字符串。 可以传入字符串文字（例如 "Sophia" 和 "Owen"），以便获取组合的字符串 "SophiaOwen"：

"customerName": "@concat('Sophia', 'Owen')"

或者，可以从参数获取字符串值。 此示例在每个 parameters() 参数以及 concat() 和 firstName 参数中使用 lastName 函数。 然后，将生成的字符串传递给 concat() 函数，以便获取组合的字符串，例如 "SophiaOwen"：

"customerName": "@concat(parameters('firstName'), parameters('lastName'))"

无论使用哪种方式，这两个示例都会将结果分配给 customerName 属性。

使用函数的注意事项

• 设计器不会计算在设计时用作函数参数的运行时表达式。 设计器要求在设计时可以完全计算所有表达式。

• 从左到右评估函数参数。

• 在参数定义的语法中，参数后显示的问号 (?) 表示参数是可选的。 有关示例，请参阅 getFutureTime()。

• 以纯文本内联显示的函数表达式需要使用封闭的大括号 ({}) 以使用表达式的内插格式。 此格式有助于避免分析问题。 如果函数表达式没有以纯文本内联显示，则无需大括号。

  以下示例显示了正确和不正确的语法：

  正确："<text>/@{<function-name>('<parameter-name>')}/<text>"

  不正确："<text>/@<function-name>('<parameter-name>')/<text>"

  没问题："@<function-name>('<parameter-name>')"

以下各部分根据函数的常规用途来划分和组织函数，也可以按字母顺序浏览这些函数。

字符串函数

若要使用字符串，可以使用这些字符串函数以及某些集合函数。 字符串函数仅适用于字符串。

集合函数

若要使用集合（通常是数组或字符串，有时是字典），可以使用这些集合函数。

逻辑比较函数

若要使用条件、比较值和表达式结果或评估各种类型的逻辑，可以使用这些逻辑比较函数。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

转换函数

若要更改值的类型或格式，可以使用这些转换函数。 例如，可将值从布尔值更改为整数。 有关 Azure 逻辑应用在转换期间如何处理内容类型的详细信息，请参阅处理内容类型。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

隐式数据类型转换

Azure 逻辑应用会自动或隐式地在某些数据类型之间进行转换，因此你无需手动执行这些转换。 例如，如果在预期应输入字符串的情况下输入了非字符串值，则 Azure 逻辑应用会自动将非字符串值转换为字符串。

例如，假设触发器返回一个数值作为输出：

triggerBody()?['123']

如果在需要字符串作为输入（如 URL）的地方使用了此数值输出值，则 Azure 逻辑应用会使用大括号 ({}) 表示法自动将该值转换为字符串：

@{triggerBody()?['123']}

Base64 编码和解码

Azure 逻辑应用会自动或隐式执行 base64 编码或解码，因此你无需使用相应的函数手动执行这些转换：

• base64(<value>)
• base64ToBinary(<value>)
• base64ToString(<value>)
• base64(decodeDataUri(<value>))
• concat('data:;base64,',<value>)
• concat('data:,',encodeUriComponent(<value>))
• decodeDataUri(<value>)

数学函数

若要使用整数和浮点数，可以使用这些数学函数。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

日期和时间函数

若要使用日期和时间，可以使用这些日期和时间函数。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

工作流函数

这些工作流函数有助于：

• 在运行时获取有关工作流实例的详细信息。
• 使用用于实例化逻辑应用或流的输入。
• 引用触发器和操作的输出。

例如，可以引用一个操作的输出，并在后面的操作中使用该数据。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

URI 分析函数

若要使用统一资源标识符 (URI) 并获取这些 URI 的各个属性值，可以使用这些 URI 分析函数。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

操作函数：JSON 和 XML

若要使用 JSON 对象和 XML 节点，可以使用这些操作函数。 有关每个函数的完整参考，请参阅按字母顺序排序的列表。

---------------------------------

所有函数 - 按字母顺序排序的列表

本部分按字母顺序列出所有可用函数。

A

操作

返回“当前”操作在运行时的输出，或者来自其他 JSON 名称和值对的值，可以将其分配给表达式。 默认情况下，此函数引用整个操作对象，但是也可以指定你需要其值的属性。 另请参阅 actions()。

只能在以下位置使用 action() 函数：

• Webhook 操作的 unsubscribe 属性，用以访问原始 subscribe 请求的结果
• 操作的 trackedProperties 属性
• 操作的 do-until 循环条件

action()
action().outputs.body.<property>

actions

返回操作在运行时的输出，或者来自其他 JSON 名称和值对的值，可以将其分配给表达式。 默认情况下，此函数引用整个操作对象，但是也可以指定你需要其值的属性。 有关简写版本，请参阅 body()。 有关当前操作，请参阅 action()。

actions('<actionName>')
actions('<actionName>').outputs.body.<property>

示例

此示例获取 X 操作 status 在运行时的 Get user 属性值：

actions('Get_user').outputs.body.status

并返回以下结果："Succeeded"

add

返回两个数字相加的结果。

add(<summand_1>, <summand_2>)

示例

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

add(1, 1.5)

并返回以下结果：2.5

addDays

将日期添加到时间戳。

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

示例 1

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

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

并返回以下结果："2018-03-25T00:00:00.0000000Z"

示例 2

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

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

并返回以下结果："2018-03-10T00:00:00.0000000Z"

addHours

将小时添加到时间戳。

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

示例 1

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

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

并返回以下结果："2018-03-15T10:00:00.0000000Z"

示例 2

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

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

并返回以下结果："2018-03-15T10:00:00.0000000Z"

addMinutes

将分钟添加到时间戳。

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

示例 1

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

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

并返回以下结果："2018-03-15T00:20:00.0000000Z"

示例 2

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

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

并返回以下结果："2018-03-15T00:15:00.0000000Z"

addProperty

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

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

若要向现有属性中添加父属性，请使用 setProperty() 函数，而不是 addProperty() 函数。 否则，该函数将仅返回子对象作为输出。

setProperty(<object>, '<parent-property>', addProperty(<object>['<parent-property>'], '<child-property>', <value>)

示例 1

此示例将 middleName 属性添加到 JSON 对象，该对象通过使用 JSON() 函数从字符串转换为 JSON。 对象已包含 firstName 和 surName 属性。 函数将指定的值分配给新属性并返回已更新的对象：

addProperty(json('{ "firstName": "Sophia", "lastName": "Owen" }'), 'middleName', 'Anne')

当前 JSON 对象如下：

{
   "firstName": "Sophia",
   "surName": "Owen"
}

已更新的 JSON 对象如下所示：

{
   "firstName": "Sophia",
   "middleName": "Anne",
   "surName": "Owen"
}

示例 2

此示例将 middleName 子属性添加到 JSON 对象中的现有 customerName 属性，该对象通过使用 JSON() 函数从字符串转换为 JSON。 函数将指定的值分配给新属性并返回已更新的对象：

setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }'), 'customerName', addProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }')['customerName'], 'middleName', 'Anne'))

当前 JSON 对象如下：

{
   "customerName": {
      "firstName": "Sophia",
      "surName": "Owen"
   }
}

已更新的 JSON 对象如下所示：

{
   "customerName": {
      "firstName": "Sophia",
      "middleName": "Anne",
      "surName": "Owen"
   }
}

addSeconds

将秒添加到时间戳。

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

示例 1

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

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

并返回以下结果："2018-03-15T00:00:10.0000000Z"

示例 2

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

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

并返回以下结果："2018-03-15T00:00:25.0000000Z"

addToTime

将指定的时间单位加到时间戳。 另请参阅 getFutureTime()。

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

示例 1

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

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

并返回以下结果："2018-01-02T00:00:00.0000000Z"

示例 2

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

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

并使用可选的“D”格式返回结果："Tuesday, January 2, 2018"

and

检查所有表达式是否为真。 当所有表达式均为 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。

数组

从单个指定的输入返回数组。 对于多个输入，请参阅 createArray()。

array('<value>')

示例

此示例基于“hello”字符串创建数组：

array('hello')

并返回以下结果：["hello"]

B

base64

返回字符串的 base64 编码版本。

base64('<value>')

示例

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

base64('hello')

并返回以下结果："aGVsbG8="

base64ToBinary

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

base64ToBinary('<value>')

示例

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

base64ToBinary('aGVsbG8=')

例如，假设你正在使用 HTTP 操作发送请求。 你可以使用 base64ToBinary() 将 base64 编码字符串转换为二进制数据，并使用请求中的 application/octet-stream 内容类型发送该数据。

base64ToString

返回 base64 编码字符串的字符串版本，有效地对 base64 字符串进行解码。 使用此函数，而不是已弃用的 decodeBase64()。

base64ToString('<value>')

示例

此示例将 base64 编码的“aGVsbG8=”字符串转换为单纯的字符串：

base64ToString('aGVsbG8=')

并返回以下结果："hello"

二进制

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

binary('<value>')

示例

例如，你使用的是返回图像或视频文件的 HTTP 操作。 可以使用 binary() 将值转换为 base64 编码的内容信封模型。 然后，可以在其他操作（如 Compose）中重复使用内容信封。 你可以使用此函数表达式发送请求中带有 application/octet-stream 内容类型的字符串字节。

body

返回操作在运行时的 body 输出。 actions('<actionName>').outputs.body 的速记。 请参阅 actions()。

body('<actionName>')

示例

此示例获取 body X 操作的 Get user 输出：

body('Get_user')

并返回以下结果：

"body": {
    "FullName": "Contoso Corporation",
    "Location": "Generic Town, USA",
    "Id": 283541717,
    "UserName": "ContosoInc",
    "FollowersCount": 172,
    "Description": "Leading the way in transforming the digital workplace.",
    "StatusesCount": 93,
    "FriendsCount": 126,
    "FavouritesCount": 46,
    "ProfileImageUrl": "https://pbs.twimg.com/profile_images/908820389907722240/gG9zaHcd_400x400.jpg"
}

布尔

返回值的布尔版本。

bool(<value>)

如果对某个对象使用 bool()，该对象的值必须是可转换为布尔值的字符串或整数。

输出

以下示例显示 bool() 支持的不同类型的输入：

C

块区 (chunk)

将字符串或数组拆分为长度相等的区块。

chunk('<collection>', '<length>')
chunk([<collection>], '<length>')

示例 1

此示例将字符串拆分为长度为 10 的区块：

chunk('abcdefghijklmnopqrstuvwxyz', 10)

并返回以下结果：['abcdefghij', 'klmnopqrst', 'uvwxyz']

示例 2

此示例将数组拆分为长度为 5 的区块。

chunk(createArray(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12), 5)

并返回以下结果：[ [1,2,3,4,5], [6,7,8,9,10], [11,12] ]

联合

返回一个或多个参数中的第一个非 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>', ...)

示例

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

concat('Hello', 'World')

并返回以下结果："HelloWorld"

contains

检查集合是否包含某个特定项。 当找到该项目时返回 true，找不到该项目时返回 false。 此函数区分大小写。

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

具体而言，此函数对以下集合类型起作用：

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

示例 1

此示例检查字符串“hello world”中是否有子字符串“world”并返回 true：

contains('hello world', 'world')

示例 2

此示例检查字符串“hello world”中是否有子字符串“universe”并返回 false：

contains('hello world', 'universe')

convertFromUtc

将时间戳从协调世界时 (UTC) 转换为目标时区。

convertFromUtc('<timestamp>', '<destinationTimeZone>', '<format>'?)

示例 1

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

convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time')

并返回以下结果："2018-01-01T00:00:00.0000000"

示例 2

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

convertFromUtc('2018-01-01T08:00:00.0000000Z', 'Pacific Standard Time', 'D')

并返回以下结果："Monday, January 1, 2018"

convertTimeZone

将时间戳从源时区转换为目标时区。

convertTimeZone('<timestamp>', '<sourceTimeZone>', '<destinationTimeZone>', '<format>'?)

示例 1

此示例将源时区转换为目标时区：

convertTimeZone('2018-01-01T08:00:00.0000000Z', 'UTC', 'Pacific Standard Time')

并返回以下结果："2018-01-01T00:00:00.0000000"

示例 2

此示例将时区转换为指定的时区和格式：

convertTimeZone('2018-01-01T80:00:00.0000000Z', 'UTC', 'Pacific Standard Time', 'D')

并返回以下结果："Monday, January 1, 2018"

convertToUtc

将时间戳从源时区转换为协调世界时 (UTC)。

convertToUtc('<timestamp>', '<sourceTimeZone>', '<format>'?)

示例 1

此示例将时间戳转换为 UTC：

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

并返回以下结果："2018-01-01T08:00:00.0000000Z"

示例 2

此示例将时间戳转换为 UTC：

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

并返回以下结果："Monday, January 1, 2018"

createArray

从多个输入返回数组。 对于单输入数组，请参阅 array()。

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

示例

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

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

并返回以下结果：["h", "e", "l", "l", "o"]

D

dataUri

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

dataUri('<value>')

示例

此示例创建“hello”字符串的数据 URI：

dataUri('hello')

并返回以下结果："data:text/plain;charset=utf-8;base64,aGVsbG8="

dataUriToBinary

返回数据统一资源标识符 (URI) 的二进制版本。 请使用此函数而非 decodeDataUri()。 虽然这两个函数的工作方式相同，但首选 dataUriBinary()。

dataUriToBinary('<value>')

示例

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

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

并返回以下结果：

"01100100011000010111010001100001001110100111010001100101011110000111010000101111011100000 1101100011000010110100101101110001110110110001101101000011000010111001001110011011001010111 0100001111010111010101110100011001100010110100111000001110110110001001100001011100110110010 10011011000110100001011000110000101000111010101100111001101100010010001110011100000111101"

dataUriToString

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

dataUriToString('<value>')

示例

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

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

并返回以下结果："hello"

日期差异

以时间跨度形式返回两个时间戳之间的差值。 此函数从 startDate 中减去 endDate，并以字符串格式的时间戳返回结果。

dateDifference('<startDate>', '<endDate>')

示例

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

dateDifference('2015-02-08', '2018-07-30')

并返回以下结果："1268.00:00:00"

dayOfMonth

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

dayOfMonth('<timestamp>')

示例

此示例返回时间戳中对应的月份日期编号。

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

并返回以下结果：15

dayOfWeek

基于时间戳返回周几。

dayOfWeek('<timestamp>')

示例

此示例将从以下时间戳中获取星期几的数字：

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

并返回以下结果：4

dayOfYear

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

dayOfYear('<timestamp>')

示例

此示例将返回以下时间戳所对应的年份中的某一天的序号：

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

并返回以下结果：74

十进制

将字符串中的小数数作为小数数返回。 当你处理需要小数精度的数据时，也可以使用此函数作为逻辑比较函数和数学函数的输入。 若要在使用 decimal() 函数的结果时捕获并保持精度，请用字符串函数包装任何小数输出。 下面的示例显示了这种用法，如果将小数结果用作数字，可能会丢失精度。

decimal('<value>')

示例 1

此示例创建一个用作数字的小数：

decimal('1.2345678912312131') // Returns 1.234567891231213.

示例 2

此示例创建一个小数，然后将结果转换为字符串以保持精度：

string(decimal('1.2345678912312131')) // Returns "1.2345678912312131".

示例 3

此示例对两个小数数字使用数学函数，并将结果用作数字：

add(decimal('1.2345678912312131'), decimal('1.2345678912312131')) // Returns 2.469135782462426.

示例 4

此示例对两个小数数字使用数学函数，并将结果转换为字符串以保持精度：

string(add(decimal('1.2345678912312131'), decimal('1.2345678912312131'))) // Returns "2.4691357824624262".

decodeBase64（已弃用）

此函数已弃用，因此请改用 base64ToString()。

decodeDataUri

返回数据统一资源标识符 (URI) 的二进制版本。 请考虑使用 dataUriToBinary() 而非 decodeDataUri()。 虽然这两个函数的工作方式相同，但首选 dataUriToBinary()。

decodeDataUri('<value>')

示例

此示例返回以下数据 URI 的二进制版本：

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

并返回以下结果："hello"

decodeUriComponent（URI 组件解码）

返回一个字符串，并将其中的转义字符替换为解码后的版本。

decodeUriComponent('<value>')

示例

此示例将以下字符串中的转义字符替换为解码后的版本：

decodeUriComponent('https%3A%2F%2Fcontoso.com')

并返回以下结果："https://contoso.com"

div

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

div(<dividend>, <divisor>)

示例 1

这两个示例都返回整数类型的以下值：2

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

示例 2

这两个示例都返回浮点类型的以下值：2.2

div(11,5.0)
div(11.0,5)

E

encodeUriComponent

通过将 URL 不安全字符替换为转义字符来返回字符串的统一资源标识符 (URI) 编码版本。 请考虑使用 uriComponent() 而非 encodeUriComponent()。 虽然这两个函数的工作方式相同，但首选 uriComponent()。

encodeUriComponent('<value>')

示例

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

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

并返回以下结果："https%3A%2F%2Fcontoso.com"

空

检查集合是否为空。 当集合为空时返回 true，不为空时返回 false。

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

示例

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

empty('')
empty('abc')

并返回以下结果：

• 第一个示例：传递一个空字符串，所以此函数返回 true。
• 第二个示例：传递字符串“abc”，所以此函数返回 false。

endsWith

检查字符串是否以特定的子字符串结尾。 当找到该子字符串时返回 true，找不到时返回 false。 此函数不区分大小写。

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

示例 1

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

endsWith('hello world', 'world')

并返回以下结果：true

示例 2

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

endsWith('hello world', 'universe')

并返回以下结果：false

equals

检查两个值、表达式或对象是否相等。 当两者相等时返回 true，两者不相等时返回 false。

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

示例

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

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

并返回以下结果：

• 第一个示例：两个值相等，所以此函数返回 true。
• 第二个示例：两个值不相等，所以此函数返回 false。

F

first

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

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

示例

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

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

并返回以下结果：

• 第一个示例："h"
• 第二个示例：0

float

将浮点数的字符串版本转换为实际的浮点数。 仅当将自定义参数传递给应用（例如，逻辑应用工作流或 Power Automate 流）时，才使用此函数。 若要转换用区域设置特定格式表示的浮点字符串，可选择指定 RFC 4646 区域设置代码。

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

示例 1

此示例创建以下浮点数的字符串版本：

float('10,000.333')

并返回以下结果：10000.333

示例 2

此示例创建以下德语样式浮点数的字符串版本：

float('10.000,333', 'de-DE')

并返回以下结果：10000.333

示例 3

意外有效的输入示例：

float('12,3,4,5678')  //Returns   12345678
float('1234567,8+')   //Returns   12345678
float('12345,6,78,-') //Returns  -12345678
float('-12,345,678,') //Returns  -12345678
float('12345678.-')   //Returns  -12345678
float('.12345678')    //Returns 0.12345678

formatDateTime

以指定的格式返回时间戳。

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

示例

formatDateTime('03/15/2018') // Returns '2018-03-15T00:00:00.0000000'.
formatDateTime('03/15/2018 12:00:00', 'yyyy-MM-ddTHH:mm:ss') // Returns '2018-03-15T12:00:00'.
formatDateTime('01/31/2016', 'dddd MMMM d') // Returns 'Sunday January 31'.
formatDateTime('01/31/2016', 'dddd MMMM d', 'fr-fr') // Returns 'dimanche janvier 31'.
formatDateTime('01/31/2016', 'dddd MMMM d', 'fr-FR') // Returns 'dimanche janvier 31'.
formatDateTime('01/31/2016', 'dddd MMMM d', 'es-es') // Returns 'domingo enero 31'.

formDataMultiValues

返回与操作的“表单数据”或“表单编码”输出中的键名称匹配的值组成的数组。

formDataMultiValues('<actionName>', '<key>')

示例

此示例基于指定操作的表单数据或表单编码输出中的“Subject”键的值创建数组。

formDataMultiValues('Send_an_email', 'Subject')

并在数组中返回主题文本，例如：["Hello world"]

formDataValue

返回与操作的“表单数据”或“表单编码”输出中的键名称匹配的单个值。 如果此函数找到多个匹配项，此函数将引发错误。

formDataValue('<actionName>', '<key>')

示例

此示例基于指定操作的表单数据或表单编码输出中的“Subject”键的值创建字符串。

formDataValue('Send_an_email', 'Subject')

并以字符串形式返回主题文本，例如："Hello world"

formatNumber

将数字作为基于指定格式的字符串返回。

formatNumber(<number>, <format>, <locale>?)

示例 1

假设要设置数字 1234567890 的格式。 此示例将该数字的格式设置为字符串“1,234,567,890.00”。

formatNumber(1234567890, '#,##0.00', 'en-US')

示例 2

假设要设置数字 1234567890 的格式。 此示例将该数字的格式设置为字符串“1.234.567.890,00”。

formatNumber(1234567890, '#,##0.00', 'is-IS')

示例 3

假设要设置数字 17.35 的格式。 此示例将该数字的格式设置为字符串“$17.35”。

formatNumber(17.35, 'C2')

示例 4

假设要设置数字 17.35 的格式。 此示例将该数字的格式设置为字符串“17,35 kr”。

formatNumber(17.35, 'C2', 'is-IS')

G

getFutureTime

返回当前时间戳加上指定的时间单位。

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

示例 1

假设当前时间戳是“2018-03-01T00:00:00.0000000Z”。 此示例将 5 天加到该时间戳：

getFutureTime(5, 'Day')

并返回以下结果："2018-03-06T00:00:00.0000000Z"

示例 2

假设当前时间戳是“2018-03-01T00:00:00.0000000Z”。 此示例加上 5 天，并将结果转换为“D”格式：

getFutureTime(5, 'Day', 'D')

并返回以下结果："Tuesday, March 6, 2018"

getPastTime

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

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

示例 1

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

getPastTime(5, 'Day')

并返回以下结果："2018-01-27T00:00:00.0000000Z"

示例 2

假设当前时间戳是“2018-02-01T00:00:00.0000000Z”。 此示例减去 5 天，并将结果转换为“D”格式：

getPastTime(5, 'Day', 'D')

并返回以下结果："Saturday, January 27, 2018"

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

GUID

生成一个字符串形式的全局唯一标识符 (GUID)，例如“c2ecc88d-88c8-4096-912c-d6f2e2b138ce”：

guid()

此外，还可以为 GUID 指定与默认格式“D”（由连字符分隔的 32 位数字）不同的格式。

guid('<format>')

示例

此示例生成相同的 GUID，但格式为 32 位数字，用连字符分隔并括在括号中:

guid('P')

并返回以下结果："(c2ecc88d-88c8-4096-912c-d6f2e2b138ce)"

I

if

检查表达式为 true 还是 false。 根据结果返回指定的值。 从左到右评估参数。

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

示例

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

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

indexOf

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

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

示例

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

indexOf('hello world', 'world')

并返回以下结果：6

整数 (int)

将整数的字符串版本转换为实际整数。

int('<value>')

示例

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

int('10')

并返回以下结果：10

isFloat

返回一个布尔值，指示字符串是否为浮点数。 默认情况下，此函数为浮点格式使用固定区域性。 若要标识用其他区域设置特定格式表示的浮点数，可选择指定 RFC 4646 区域设置代码。

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

示例 1

此示例检查字符串是否为固定区域性中的浮点数：

isFloat('10,000.00')

并返回以下结果：true

示例 2

此示例检查字符串是否为采用德语区域设置的浮点数：

isFloat('10.000,00', 'de-DE')

并返回以下结果：true

isInt

返回一个布尔值，指示字符串是否为整数。

isInt('<string>')

示例

此示例检查字符串是否为整数：

isInt('10')

并返回以下结果：true

项

当在针对数组的重复操作中使用时，返回在操作的当前迭代过程中数组中的当前项。 还可以获取该项的属性中的值。

item()

示例

此示例在 for-each 循环的当前迭代中从“Send_an_email”操作的当前消息中获取 body 元素：

item().body

items

返回 for-each 循环中每个周期的当前项。 请在 for-each 循环中使用此函数。

items('<loopName>')

示例

此示例获取指定 for-each 循环的当前项：

items('myForEachLoopName')

iterationIndexes

返回 Until 循环中当前迭代的索引值。 可以在嵌套的 Until 循环中使用此函数。

iterationIndexes('<loopName>')

示例

此示例将创建一个计数器变量，并在 Until 循环的每次迭代中将该变量递增 1，直至计数器值达到 5。 此示例还将创建一个变量，该变量跟踪每次迭代的当前索引。 在 Until 循环的每次迭代时，此示例会递增计数器值，然后将该值指定给当前索引值，然后再递增计数器值。 在此循环中，此示例使用 iterationIndexes 函数引用当前迭代索引：

iterationIndexes('Until_Max_Increment')

{
   "actions": {
      "Create_counter_variable": {
         "type": "InitializeVariable",
         "inputs": {
            "variables": [ 
               {
                  "name": "myCounter",
                  "type": "Integer",
                  "value": 0
               }
            ]
         },
         "runAfter": {}
      },
      "Create_current_index_variable": {
         "type": "InitializeVariable",
         "inputs": {
            "variables": [
               {
                  "name": "myCurrentLoopIndex",
                  "type": "Integer",
                  "value": 0
               }
            ]
         },
         "runAfter": {
            "Create_counter_variable": [ "Succeeded" ]
         }
      },
      "Until_Max_Increment": {
         "type": "Until",
         "actions": {
            "Assign_current_index_to_counter": {
               "type": "SetVariable",
               "inputs": {
                  "name": "myCurrentLoopIndex",
                  "value": "@variables('myCounter')"
               },
               "runAfter": {
                  "Increment_variable": [ "Succeeded" ]
               }
            },
            "Compose": {
               "inputs": "'Current index: ' @{iterationIndexes('Until_Max_Increment')}",
               "runAfter": {
                  "Assign_current_index_to_counter": [
                     "Succeeded"
                    ]
                },
                "type": "Compose"
            },           
            "Increment_variable": {
               "type": "IncrementVariable",
               "inputs": {
                  "name": "myCounter",
                  "value": 1
               },
               "runAfter": {}
            }
         },
         "expression": "@equals(variables('myCounter'), 5)",
         "limit": {
            "count": 60,
            "timeout": "PT1H"
         },
         "runAfter": {
            "Create_current_index_variable": [ "Succeeded" ]
         }
      }
   }
}

J

json

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

json('<value>')
json(xml('value'))

示例 1

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

json('[1, 2, 3]')

并返回以下结果：[1, 2, 3]

示例 2

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

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

并返回以下结果：

{
  "fullName": "Sophia Owen"
}

示例 3

此示例使用 json() 和 xml() 函数将根元素中具有单个子元素的 XML 转换为该子元素的名为 person 的 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"
      }
   }
}

示例 4

此示例使用 json() 和 xml() 函数将根元素中具有多个子元素的 XML 转换为一个数组，其中包含这些子元素的名为 person 的 JSON 对象：

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

并返回以下结果：

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

交集

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

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

示例

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

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

并返回仅包含这些项的数组：

加入

返回一个字符串，它包含某个数组中的所有项并且以分隔符分隔每个字符。

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

示例

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

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

并返回以下结果："a.b.c"

L

last

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

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

示例

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

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

并返回以下结果：

• 第一个示例："d"
• 第二个示例：3

lastIndexOf

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

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

如果字符串或子字符串值为空，则会出现以下行为：

• 如果只有字符串值为空，该函数将返回 -1。

• 如果字符串和子字符串值均为空，该函数将返回 0。

• 如果只有子字符串值为空，该函数将返回字符串长度减 1 后的值。

示例

此示例查找 world 字符串中最后一次出现的 hello world hello world 子字符串的起始索引值。 返回的结果为 18：

lastIndexOf('hello world hello world', 'world')

此示例缺少子字符串参数，将返回 22 值，因为输入字符串 (23) 减 1 后的值大于 0。

lastIndexOf('hello world hello world', '')

长度

返回集合中的项数。

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

示例

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

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

并返回以下结果：4

less

检查第一个值是否小于第二个值。 如果第一个值小，则返回 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

listCallbackUrl

返回调用某个触发器或操作的“回调 URL”。 此函数仅对适用于 HttpWebhook 和 ApiConnectionWebhook 连接器类型的触发器和操作起作用，对 Manual、Recurrence、HTTP 和 APIConnection 类型不起作用。

listCallbackUrl()

示例

此示例显示了此函数可能会返回的示例回调 URL：

"https://prod-01.westus.logic.azure.com:443/workflows/<*workflow-ID*>/triggers/manual/run?api-version=2016-10-01&sp=%2Ftriggers%2Fmanual%2Frun&sv=1.0&sig=<*signature-ID*>"

M

max

返回列表中或包括两端数字在内的数组中的最大值。

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

示例

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

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

并返回以下结果：3

min

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

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

示例

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

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

并返回以下结果：1

mod

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

mod(<dividend>, <divisor>)

示例 1

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

mod(3, 2)

并返回以下结果：1

示例 2

此示例表明，如果一个值或两个值为负，则结果与被除数的符号匹配：

mod(-5, 2)
mod(4, -3)

此示例返回以下结果：

• 第一个示例：-1
• 第二个示例：1

mul

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

mul(<multiplicand1>, <multiplicand2>)

示例

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

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

并返回以下结果：

• 第一个示例：2
• 第二个示例：3

multipartBody

返回具有多个部分的操作输出中某个特定部分的正文。

multipartBody('<actionName>', <index>)

N

不

判断表达式是否为假。 当表达式为 false 时返回 true，当表达式为 true 时返回 false。

not(<expression>)

示例 1

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

not(false)
not(true)

并返回以下结果：

• 第一个示例：表达式为 false，所以此函数返回 true。
• 第二个示例：表达式为 true，所以此函数返回 false。

示例 2

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

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

并返回以下结果：

• 第一个示例：表达式为 false，所以此函数返回 true。
• 第二个示例：表达式为 true，所以此函数返回 false。

nthIndexOf

返回子字符串第 n 次出现在字符串中的起始位置或索引值。

nthIndexOf('<text>', '<searchText>', <occurrence>)

示例

nthIndexOf('123456789123465789', '1', 1) // Returns `0`.
nthIndexOf('123456789123465789', '1', 2) // Returns `9`.
nthIndexOf('123456789123465789', '12', 2) // Returns `9`.
nthIndexOf('123456789123465789', '6', 4) // Returns `-1`.

O

或

检查是否至少一个表达式为真。 当至少一个表达式为 true 时返回 true，当所有表达式均为 false 时返回 false。

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

示例 1

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

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

并返回以下结果：

• 第一个示例：至少一个表达式为 true，所以此函数返回 true。
• 第二个示例：两个表达式均为 false，所以此函数返回 false。

示例 2

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

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

并返回以下结果：

• 第一个示例：至少一个表达式为 true，所以此函数返回 true。
• 第二个示例：两个表达式均为 false，所以此函数返回 false。

outputs

返回操作在运行时的输出。

outputs('<actionName>')

示例

此示例从 X 操作 Get user 获取输出：

outputs('Get_user')

并返回以下结果：

{
  "statusCode": 200,
  "headers": {
    "Pragma": "no-cache",
    "Vary": "Accept-Encoding",
    "x-ms-request-id": "a916ec8f52211265d98159adde2efe0b",
    "X-Content-Type-Options": "nosniff",
    "Timing-Allow-Origin": "*",
    "Cache-Control": "no-cache",
    "Date": "Mon, 09 Apr 2018 18:47:12 GMT",
    "Set-Cookie": "ARRAffinity=b9400932367ab5e3b6802e3d6158afffb12fcde8666715f5a5fbd4142d0f0b7d;Path=/;HttpOnly;Domain=twitter-wus.azconn-wus.p.azurewebsites.net",
    "X-AspNet-Version": "4.0.30319",
    "X-Powered-By": "ASP.NET",
    "Content-Type": "application/json; charset=utf-8",
    "Expires": "-1",
    "Content-Length": "339"
  },
  "body": {
    "FullName": "Contoso Corporation",
    "Location": "Generic Town, USA",
    "Id": 283541717,
    "UserName": "ContosoInc",
    "FollowersCount": 172,
    "Description": "Leading the way in transforming the digital workplace.",
    "StatusesCount": 93,
    "FriendsCount": 126,
    "FavouritesCount": 46,
    "ProfileImageUrl": "https://pbs.twimg.com/profile_images/908820389907722240/gG9zaHcd_400x400.jpg"
  }
}

P

参数

返回工作流定义中描述的参数的值。

parameters('<parameterName>')

示例

假设具有以下 JSON 值：

{
  "fullName": "Sophia Owen"
}

此示例获取指定参数的值：

parameters('fullName')

并返回以下结果："Sophia Owen"

parseDateTime

从包含时间戳的字符串中返回时间戳。

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

示例

parseDateTime('20/10/2014', 'fr-fr') // Returns '2014-10-20T00:00:00.0000000'.
parseDateTime('20 octobre 2010', 'fr-FR') // Returns '2010-10-20T00:00:00.0000000'.
parseDateTime('martes 20 octubre 2020', 'es-es') // Returns '2020-10-20T00:00:00.0000000'.
parseDateTime('21052019', 'fr-fr', 'ddMMyyyy') // Returns '2019-05-21T00:00:00.0000000'.
parseDateTime('20190521', 'fr-fr', 'yyyyMMdd') // Returns '2019-05-21T00:00:00.0000000'.
parseDateTime('10/20/2014 15h', 'en-US', 'MM/dd/yyyy HH\h') // Returns '2014-10-20T15:00:00.0000000'.

R

兰特

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

rand(<minValue>, <maxValue>)

示例

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

rand(1, 5)

并返回下列数字之一作为结果：1、2、3 或 4

范围

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

range(<startIndex>, <count>)

示例

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

range(1, 4)

并返回以下结果：[1, 2, 3, 4]

removeProperty

从对象中删除属性，并返回更新后的对象。 如果尝试删除的属性不存在，则函数将返回原始对象。

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

若要从现有属性中删除子属性，请使用以下语法：

removeProperty(<object>['<parent-property>'], '<child-property>')

示例 1

此示例从 JSON 对象中删除 middleName 属性，该对象通过使用 JSON() 函数从字符串转换为 JSON，并返回已更新的对象：

removeProperty(json('{ "firstName": "Sophia", "middleName": "Anne", "surName": "Owen" }'), 'middleName')

当前 JSON 对象如下：

{
   "firstName": "Sophia",
   "middleName": "Anne",
   "surName": "Owen"
}

已更新的 JSON 对象如下所示：

{
   "firstName": "Sophia",
   "surName": "Owen"
}

示例 2

此示例从 JSON 对象中的 middleName 父属性中删除 customerName 子属性，该对象通过使用 JSON() 函数从字符串转换为 JSON，并返回已更新的对象：

removeProperty(json('{ "customerName": { "firstName": "Sophia", "middleName": "Anne", "surName": "Owen" } }')['customerName'], 'middleName')

当前 JSON 对象如下：

{
   "customerName": {
      "firstName": "Sophia",
      "middleName": "Anne",
      "surName": "Owen"
   }
}

已更新的 JSON 对象如下所示：

{
   "customerName": {
      "firstName": "Sophia",
      "surName": "Owen"
   }
}

替换

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

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

示例

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

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

并返回以下结果："the new string"

result

返回指定的有范围操作（例如 For_each、Until 或 Scope 操作）中顶级操作的结果。 result() 函数接受单个参数（范围的名称），并返回一个数组，其中包含该范围内的顶级操作中的信息。 这些操作对象包含的特性（例如操作的开始时间、结束时间、状态、输入、相关 ID 和输出）与 actions() 函数返回的特性相同。

例如，可以使用此函数获取失败操作的结果，以便可以诊断和处理异常。 有关详细信息，请参阅获取失败情况的上下文和结果。

result('<scopedActionName>')

示例

此示例通过在 For_each 操作中使用 result() 函数，返回 Compose 循环中 HTTP 操作的每次迭代的输入和输出：

{
   "actions": {
      "Compose": {
         "inputs": "@result('For_each')",
         "runAfter": {
            "For_each": [
               "Succeeded"
            ]
         },
         "type": "compose"
      },
      "For_each": {
         "actions": {
            "HTTP": {
               "inputs": {
                  "method": "GET",
                  "uri": "https://httpstat.us/200"
               },
               "runAfter": {},
               "type": "Http"
            }
         },
         "foreach": "@triggerBody()",
         "runAfter": {},
         "type": "Foreach"
      }
   }
}

示例返回的数组如下所示，其中，外部 outputs 对象包含 For_each 操作中操作的每次迭代的输入和输出。

[
   {
      "name": "HTTP",
      "outputs": [
         {
            "name": "HTTP",
            "inputs": {
               "uri": "https://httpstat.us/200",
               "method": "GET"
            },
            "outputs": {
               "statusCode": 200,
               "headers": {
                   "X-AspNetMvc-Version": "5.1",
                   "Access-Control-Allow-Origin": "*",
                   "Cache-Control": "private",
                   "Date": "Tue, 20 Aug 2019 22:15:37 GMT",
                   "Set-Cookie": "ARRAffinity=0285cfbea9f2ee7",
                   "Server": "Microsoft-IIS/10.0",
                   "X-AspNet-Version": "4.0.30319",
                   "X-Powered-By": "ASP.NET",
                   "Content-Length": "0"
               },
               "startTime": "2019-08-20T22:15:37.6919631Z",
               "endTime": "2019-08-20T22:15:37.95762Z",
               "trackingId": "6bad3015-0444-4ccd-a971-cbb0c99a7.....",
               "clientTrackingId": "085863526764.....",
               "code": "OK",
               "status": "Succeeded"
            }
         },
         {
            "name": "HTTP",
            "inputs": {
               "uri": "https://httpstat.us/200",
               "method": "GET"
            },
            "outputs": {
            "statusCode": 200,
               "headers": {
                   "X-AspNetMvc-Version": "5.1",
                   "Access-Control-Allow-Origin": "*",
                   "Cache-Control": "private",
                   "Date": "Tue, 20 Aug 2019 22:15:37 GMT",
                   "Set-Cookie": "ARRAffinity=0285cfbea9f2ee7",
                   "Server": "Microsoft-IIS/10.0",
                   "X-AspNet-Version": "4.0.30319",
                   "X-Powered-By": "ASP.NET",
                   "Content-Length": "0"
               },
               "startTime": "2019-08-20T22:15:37.6919631Z",
               "endTime": "2019-08-20T22:15:37.95762Z",
               "trackingId": "9987e889-981b-41c5-aa27-f3e0e59bf69.....",
               "clientTrackingId": "085863526764.....",
               "code": "OK",
               "status": "Succeeded"
            }
         }
      ]
   }
]

REVERSE

颠倒集合中的项的顺序。 结合使用此函数和 sort() 时，可按降序对集合进行排序。

reverse([<collection>])

示例

此示例对整数数组进行反转：

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

并返回此数组：[3,2,1,0]

S

setProperty

设置 JSON 对象的属性值并返回更新的对象。 如果尝试设置的属性不存在，则会将该属性添加到对象。 若要添加新属性，请使用 addProperty() 函数。

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

若要设置子对象中的子属性，请改用嵌套的 setProperty() 调用。 否则，该函数将仅返回子对象作为输出。

setProperty(<object>, '<parent-property>', setProperty(<object>['parentProperty'], '<child-property>', <value>))

示例 1

此示例在 JSON 对象中设置 surName 属性，该对象通过使用 JSON() 函数从字符串转换为 JSON。 函数将指定的值分配给属性并返回已更新的对象：

setProperty(json('{ "firstName": "Sophia", "surName": "Owen" }'), 'surName', 'Hartnett')

当前 JSON 对象如下：

{
   "firstName": "Sophia",
   "surName": "Owen"
}

已更新的 JSON 对象如下所示：

{
   "firstName": "Sophia",
   "surName": "Hartnett"
}

示例 2

此示例设置 JSON 对象中 surName 父属性的 customerName 子属性，该对象通过使用 JSON() 函数从字符串转换为 JSON。 函数将指定的值分配给属性并返回已更新的对象：

setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }'), 'customerName', setProperty(json('{ "customerName": { "firstName": "Sophia", "surName": "Owen" } }')['customerName'], 'surName', 'Hartnett'))

当前 JSON 对象如下：

{
   "customerName": {
      "firstName": "Sophie",
      "surName": "Owen"
   }
}

已更新的 JSON 对象如下所示：

{
   "customerName": {
      "firstName": "Sophie",
      "surName": "Hartnett"
   }
}

跳过

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

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

示例

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

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

并返回包含剩余项的以下数组：[1,2,3]

切分

通过指定起始位置和结束位置或值返回子字符串。 另请参阅 substring()。

slice('<text>', <startIndex>, <endIndex>?)

示例

slice('Hello World', 2) // Returns 'llo World'.
slice('Hello World', 30) // Returns ''.
slice('Hello World', 10, 2) // Returns ''.
slice('Hello World', 0) // Returns 'Hello World'.
slice('Hello World', 2, 5) // Returns 'llo'.
slice('Hello World', 6, 20) // Returns 'World'.
slice('Hello World', -2) // Returns 'ld'.
slice('Hello World', 3, -1) // Returns 'lo Worl'.
slice('Hello World', 3, 3) // Returns ''.

排序

为集合中的项排序。 可以使用包含简单类型的任何键对集合对象进行排序。

sort([<collection>], <sortBy>?)

示例 1

此示例对整数数组进行排序：

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

并返回此数组：[0,1,2,3]

示例 2

此示例按键对对象数组进行排序：

sort(createArray(json('{ "first": "Amalie", "last": "Rose" }'), json('{ "first": "Elise", "last": "Renee" }')), 'last')

并返回此数组：[{ "first": "Elise", "last": "Renee" }, {"first": "Amalie", "last": "Rose" }')]

拆分

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

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

示例 1

此示例根据作为分隔符的指定字符，从指定字符串创建具有子字符串的数组：

split('a_b_c', '_')

并将此数组作为以下结果返回：["a","b","c"]

示例 2

当字符串中不存在分隔符时，此示例创建具有单个元素的阵列：

split('a_b_c', ' ')

并将此数组作为以下结果返回：["a_b_c"]

startOfDay

返回时间戳中的天的开始时间。

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

示例

此示例查找以下时间戳中的天的开始时间：

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

并返回以下结果："2018-03-15T00:00:00.0000000Z"

startOfHour

返回时间戳中的小时的开始时间。

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

示例

此示例用于查找该时间戳中小时的起始时间。

startOfHour('2018-03-15T13:30:30Z')

并返回以下结果："2018-03-15T13:00:00.0000000Z"

startOfMonth

返回时间戳中的月份的开始时间。

startOfMonth('<timestamp>', '<format>'?)

示例 1

此示例查找以下时间戳中月份的开始时间：

startOfMonth('2018-03-15T13:30:30Z')

并返回以下结果："2018-03-01T00:00:00.0000000Z"

示例 2

此示例返回此时间戳的月份的开始时间（采用指定格式）：

startOfMonth('2018-03-15T13:30:30Z', 'yyyy-MM-dd')

并返回以下结果："2018-03-01"

startsWith

检查字符串是否以特定的子字符串开头。 当找到该子字符串时返回 true，找不到时返回 false。 此函数不区分大小写。

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

示例 1

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

startsWith('hello world', 'hello')

并返回以下结果：true

示例 2

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

startsWith('hello world', 'greetings')

并返回以下结果：false

字符串

返回值的字符串版本。

string(<value>)

示例 1

此示例创建以下数字的字符串版本：

string(10)

并返回以下结果："10"

示例 2

此示例为指定的 JSON 对象创建字符串并使用反斜杠字符 (\) 作为双引号 (") 的转义字符。

string( { "name": "Sophie Owen" } )

并返回以下结果："{ \\"name\\": \\"Sophie Owen\\" }"

sub

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

sub(<minuend>, <subtrahend>)

示例

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

sub(10.3, .3)

并返回以下结果：10

substring

返回字符串中的字符，从指定的位置或索引开始。 索引值从数字 0 开始。 另请参阅 slice()。

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

示例

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

substring('hello world', 6, 5)

并返回以下结果："world"

subtractFromTime

从时间戳中减去一定数目的时间单位。 另请参阅 getPastTime。

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

示例 1

此示例从以下时间戳中减去 1 天：

subtractFromTime('2018-01-02T00:00:00Z', 1, 'Day')

并返回以下结果："2018-01-01T00:00:00.0000000Z"

示例 2

此示例从以下时间戳中减去 1 天：

subtractFromTime('2018-01-02T00:00:00Z', 1, 'Day', 'D')

并使用可选的“D”格式返回以下结果："Monday, January, 1, 2018"

T

take

返回集合开头的项。

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

示例

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

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

并返回以下结果：

• 第一个示例："abc"
• 第二个示例：[0, 1, 2]

ticks

返回自 0001 年 1 月 1 日午夜 12:00:00（或 C# 中的 DateTime.Ticks）到指定时间戳的间隔为 100 毫微秒的时钟周期数。 有关详细信息，请参阅本主题：DateTime.Ticks 属性 (System)。

ticks('<timestamp>')

toLower

返回小写格式的字符串。 如果字符串中的某个字符没有对应的小写版本，则该字符在返回的字符串中保持原样。

toLower('<text>')

示例

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

toLower('Hello World')

并返回以下结果："hello world"

toUpper

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

toUpper('<text>')

示例

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

toUpper('Hello World')

并返回以下结果："HELLO WORLD"

触发

返回触发器在运行时的输出，或者来自其他 JSON 名称和值对的值，可以将其分配给表达式。

• 在触发器的输入中，此函数返回来自上次执行的输出。

• 在触发器的条件中，此函数返回来自当前执行的输出。

默认情况下，此函数引用整个触发器对象，但是也可以指定你需要其值的属性。 此外，此函数还提供了速记版本，请参阅 triggerOutputs() 和 triggerBody()。

trigger()

triggerBody

返回触发器在运行时的 body 输出。 trigger().outputs.body 的速记。 请参阅 trigger()。

triggerBody()

triggerFormDataMultiValues

返回与触发器的“表单数据”或“表单编码”输出中的键名称匹配的值组成的数组。

triggerFormDataMultiValues('<key>')

示例

此示例基于 RSS 触发器的表单数据或表单编码输出中的“feedUrl”键值创建数组：

triggerFormDataMultiValues('feedUrl')

并将以下数组返回为示例结果：["https://feeds.a.dj.com/rss/RSSMarketsMain.xml"]

triggerFormDataValue

返回一个字符串，其中包含与触发器的“表单数据”或“表单编码”输出中的键名称匹配的单个值。 如果此函数找到多个匹配项，此函数将引发错误。

triggerFormDataValue('<key>')

示例

此示例基于 RSS 触发器的表单数据或表单编码输出中的“feedUrl”键值创建字符串：

triggerFormDataValue('feedUrl')

并将以下字符串返回为示例结果："https://feeds.a.dj.com/rss/RSSMarketsMain.xml"

triggerMultipartBody

返回具有多个部分的触发器输出中某个特定部分的正文。

triggerMultipartBody(<index>)

triggerOutputs

返回触发器在运行时的输出，或者来自其他 JSON 名称和值对的值。 trigger().outputs 的速记。 请参阅 trigger()。

triggerOutputs()

剪裁

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

trim('<text>')

示例

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

trim(' Hello World  ')

并返回以下结果："Hello World"

U

并

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

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

示例

此示例获取这些集合中的所有项：

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

并返回以下结果：[1, 2, 3, 10, 101]

uriComponent

通过将 URL 不安全字符替换为转义字符来返回字符串的统一资源标识符 (URI) 编码版本。 请使用此函数而非 encodeUriComponent()。 虽然这两个函数的工作方式相同，但首选 uriComponent()。

uriComponent('<value>')

示例

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

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

并返回以下结果："https%3A%2F%2Fcontoso.com"

uriComponentToBinary

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

uriComponentToBinary('<value>')

示例

此示例创建以下 URI 编码字符串的二进制版本：

uriComponentToBinary('https%3A%2F%2Fcontoso.com')

并返回以下结果："aHR0cHM6Ly9jb250b3NvLmNvbQ=="

uriComponentToString

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

uriComponentToString('<value>')

示例

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

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

并返回以下结果："https://contoso.com"

uriHost

返回统一资源标识符 (URI) 的 host 值。

uriHost('<uri>')

示例

此示例查找以下 URI 的 host 值：

uriHost('https://www.localhost.com:8080')

并返回以下结果："www.localhost.com"

uriPath

返回统一资源标识符 (URI) 的 path 值。

uriPath('<uri>')

示例

此示例查找以下 URI 的 path 值：

uriPath('https://www.contoso.com/catalog/shownew.htm?date=today')

并返回以下结果："/catalog/shownew.htm"

uriPathAndQuery

返回统一资源标识符 (URI) 的 path 和 query 值。

uriPathAndQuery('<uri>')

示例

此示例查找以下 URI 的 path 和 query 值：

uriPathAndQuery('https://www.contoso.com/catalog/shownew.htm?date=today')

并返回以下结果："/catalog/shownew.htm?date=today"

uriPort

返回统一资源标识符 (URI) 的 port 值。

uriPort('<uri>')

示例

此示例查找以下 URI 的 port 值：

uriPort('https://www.localhost:8080')

并返回以下结果：8080

uriQuery

返回统一资源标识符 (URI) 的 query 值。

uriQuery('<uri>')

示例

此示例查找以下 URI 的 query 值：

uriQuery('https://www.contoso.com/catalog/shownew.htm?date=today')

并返回以下结果："?date=today"

uriScheme

返回统一资源标识符 (URI) 的 scheme 值。

uriScheme('<uri>')

示例

此示例查找以下 URI 的 scheme 值：

uriScheme('https://www.contoso.com/catalog/shownew.htm?date=today')

并返回以下结果："http"

utcNow

返回当前时间戳。

utcNow('<format>')

另外，也可以使用 <format 参数指定不同的格式。

示例 1

假设今天的当前时间为 2018 年 4 月 15 日下午 1:00:00。 此示例获取当前时间戳：

utcNow()

并返回以下结果："2018-04-15T13:00:00.0000000Z"

示例 2

假设今天的当前时间为 2018 年 4 月 15 日下午 1:00:00。 此示例使用可选的“D”格式获取当前时间戳：

utcNow('D')

并返回以下结果："Sunday, April 15, 2018"

V

变量

返回指定变量的值。

variables('<variableName>')

示例

假设“numItems”变量的当前值为 20。 此示例获取以下变量的整数值：

variables('numItems')

并返回以下结果：20

W

工作流

返回运行期间有关工作流本身的所有详细信息。

workflow().<property>

示例 1

此示例返回工作流的当前运行的名称：

workflow().run.name

示例 2

如果使用 Power Automate，可以创建一个使用 @workflow() 输出属性从流的 tags 或 flowDisplayName 属性获取值的 environmentName 表达式。

例如，可以从流本身发送链接回到你的流的自定义电子邮件通知。 这些通知可以包含一个 HTML 链接，其中包含流在电子邮件标题中的显示名称。该链接遵循以下语法：

<a href=https://flow.microsoft.com/manage/environments/@{workflow()['tags']['environmentName']}/flows/@{workflow()['name']}/details>Open flow @{workflow()['tags']['flowDisplayName']}</a>

X

xml

返回包含 JSON 对象的字符串的 XML 版本。

xml('<value>')

示例 1

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

xml('<name>Sophia Owen</name>')

并返回以下结果 XML：

<name>Sophia Owen</name>

示例 2

此示例创建包含 JSON 对象的以下字符串的 XML 版本：

xml(json('{ "name": "Sophia Owen" }'))

并返回以下结果 XML：

<name>Sophia Owen</name>

示例 3

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

示例 1

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

此示例传入 XPath 表达式 '/produce/item/name/text()'，以查找与 <name></name> XML 字符串中的 'items' 节点匹配的节点，并返回包含这些节点值的数组：

xpath(xml(parameters('items')), '/produce/item/name/text()')

此示例还使用 parameters() 函数从 'items' 获取 XML 字符串，并使用 xml() 函数将该字符串转换为 XML 格式。

以下结果数组填充了与 <name></name> 匹配的节点的值：

[ Gala, Honeycrisp ]

示例 2

此示例是示例 1 的延续，它传入 XPath 表达式 '/produce/item/name[1]' 来查找作为 name 元素的子级的第一个 item 元素。

xpath(xml(parameters('items')), '/produce/item/name[1]')

结果如下：Gala

示例 3

此示例是示例 1 的延续，它传入 XPath 表达式 '/produce/item/name[last()]' 来查找作为 name 元素的子级的最后一个 item 元素。

xpath(xml(parameters('items')), '/produce/item/name[last()]')

结果如下：Honeycrisp

示例 4

此示例假设 items XML 字符串还包含特性 expired='true' 和 expired='false'：

<?xml version="1.0"?>
<produce>
  <item>
    <name expired='true'>Gala</name>
    <type>apple</type>
    <count>20</count>
  </item>
  <item>
    <name expired='false'>Honeycrisp</name>
    <type>apple</type>
    <count>10</count>
  </item>
</produce>

此示例传入 XPath 表达式 '//name[@expired]' 来查找具有 name 特性的所有 expired 元素：

xpath(xml(parameters('items')), '//name[@expired]')

结果如下：[ Gala, Honeycrisp ]

示例 5

此示例假设 items XML 字符串只包含特性 expired = 'true'：

<?xml version="1.0"?>
<produce>
  <item>
    <name expired='true'>Gala</name>
    <type>apple</type>
    <count>20</count>
  </item>
  <item>
    <name>Honeycrisp</name>
    <type>apple</type>
    <count>10</count>
  </item>
</produce>

此示例传入 XPath 表达式 '//name[@expired = 'true']' 来查找具有 name 特性的所有 expired = 'true' 元素：

xpath(xml(parameters('items')), '//name[@expired = 'true']')

结果如下：[ Gala ]

示例 6

此示例假设 items XML 字符串还包含以下特性：

• expired='true' price='12'
• expired='false' price='40'

<?xml version="1.0"?>
<produce>
  <item>
    <name expired='true' price='12'>Gala</name>
    <type>apple</type>
    <count>20</count>
  </item>
  <item>
    <name expired='false' price='40'>Honeycrisp</name>
    <type>apple</type>
    <count>10</count>
  </item>
</produce>

此示例传入 XPath 表达式 '//name[@price>35]' 来查找具有 name 的所有 price > 35 元素：

xpath(xml(parameters('items')), '//name[@price>35]')

结果如下：Honeycrisp

示例 7

此示例假设 items XML 字符串与示例 1 中的字符串相同：

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

此示例查找与 <count></count> 节点匹配的节点并通过 sum() 函数添加这些节点值：

xpath(xml(parameters('items')), 'sum(/produce/item/count)')

结果如下：30

示例 8

此示例假设你有以下 XML 字符串，其中包含 XML 文档命名空间 xmlns="https://contoso.com"：

<?xml version="1.0"?><file xmlns="https://contoso.com"><location>Paris</location></file>

这些表达式使用 XPath 表达式 /*[name()="file"]/*[name()="location"] 或 /*[local-name()="file" and namespace-uri()="https://contoso.com"]/*[local-name()="location"] 来查找与 <location></location> 节点匹配的节点。 这些示例演示了在设计器或表达式编辑器中使用的语法：

• xpath(xml(body('Http')), '/*[name()="file"]/*[name()="location"]')
• xpath(xml(body('Http')), '/*[local-name()="file" and namespace-uri()="https://contoso.com"]/*[local-name()="location"]')

下面是与 <location></location> 节点匹配的结果节点：

<location xmlns="https://contoso.com">Paris</location>

示例 9

此示例是示例 8 的延续，它使用 XPath 表达式 'string(/*[name()="file"]/*[name()="location"])' 来查找 <location></location> 节点中的值：

xpath(xml(body('Http')), 'string(/*[name()="file"]/*[name()="location"])')

结果如下：Paris

后续步骤

了解工作流定义语言