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

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

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

例如，当需要整数或浮点数求和时，可以使用数学函数（如 add（） 函数）来计算值。 下面是可以使用函数执行的其他示例任务：

若要 根据函数的常规用途查找函数，请查看下表。 或者，有关每个函数的详细信息，请参阅 字母顺序列表。

表达式中的函数

为了演示如何在表达式中使用函数，此示例演示如何从customerName参数获取值，并在表达式中使用 parameters（） 函数将该accountName值分配给属性：

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

下面是在表达式中使用函数的其他一些常规方法：

例如，该 concat() 函数可以将两个或多个字符串值作为参数。 此函数将这些字符串合并为一个字符串。 可以传入字符串文本，例如“索菲亚”和“Owen”，以便获得组合字符串“索菲亚”：

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

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

"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 名称和值对中的值，你可以将其分配给表达式。 默认情况下，此函数引用整个作对象，但可以选择指定所需的属性。 另请参阅作（）。

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

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

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

行动

在运行时返回作的输出，或其他 JSON 名称和值对中的值，你可以将其分配给表达式。 默认情况下，该函数引用整个作对象，但可以选择指定所需的属性。 有关速记版本，请参阅正文（）。 有关当前作，请参阅 action（）。

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

示例

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

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

并返回以下结果： "Succeeded"

添加

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

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

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

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

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

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

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

addToTime

将指定的时间单位添加到时间戳。 另请参阅 getFutureTime（）。

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

示例 1

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

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

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

示例 2

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

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

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

和

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

数组

从单个指定输入返回数组。 有关多个输入，请参阅 createArray（）。

array('<value>')

示例

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

array('hello')

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

B

base64

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

base64('<value>')

示例

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

base64('hello')

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

base64ToBinary

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

base64ToBinary('<value>')

示例

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

base64ToBinary('aGVsbG8=')

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

base64ToString

返回 base64 编码字符串的字符串版本，有效解码 base64 字符串。 使用此函数，而不是解码已弃用的Base64（）。

base64ToString('<value>')

示例

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

base64ToString('aGVsbG8=')

并返回以下结果： "hello"

二进制

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

binary('<value>')

示例

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

身体

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

body('<actionName>')

示例

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

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('<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"

包含

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

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

具体而言，此函数适用于以下集合类型：

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

示例 1

此示例检查子字符串“world”的字符串“hello world”，并返回 true：

contains('hello world', 'world')

示例 2

此示例检查子字符串“universe”的字符串“hello world”，并返回 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"

dateDifference

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

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

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

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

这两个示例都返回具有 Float 类型的此值： 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。

以……结束

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

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

示例 1

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

endsWith('hello world', 'world')

并返回以下结果： true

示例 2

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

endsWith('hello world', 'universe')

并返回以下结果： false

等于

检查两个值、表达式还是对象是否等效。 当两者都等效时返回 true，或者返回 false（当它们不等效时）。

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

示例

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

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

并返回以下结果：

• 第一个示例：这两个值都是等效的，因此函数返回 true。
• 第二个示例：两个值都不等效，因此函数返回 false。

F

第一

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

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

formatDateTime

以指定格式返回时间戳。

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

Examples

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”。 此示例向该时间戳添加五天：

getFutureTime(5, 'Day')

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

示例 2

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

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

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

getPastTime

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

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

示例 1

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

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"

大

检查第一个值是否大于第二个值。 当第一个值更多时返回 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 循环中每次迭代期间逐个递增该变量，直到计数器值达到 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))

返回 仅 包含以下项的数组： [1, 2]

加入

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

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

示例

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

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

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

L

最后

从集合中返回最后一项。

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

示例

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

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

并返回以下结果：

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

lastIndexOf

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

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

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

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

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

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

Examples

本示例查找字符串hello world hello world中子字符串world的最后一个匹配项的起始索引值。 返回的结果为 18：

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

此示例缺少子字符串参数，并返回一个值 22 ，因为输入字符串 （23） 减 1 的值大于 0。

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

length

返回集合中的项数。

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

示例

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

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

并返回以下结果： 4

少

检查第一个值是否小于第二个值。 当第一个值较少时返回 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

listCallbackUrl

返回调用触发器或作的“回调 URL”。 此函数仅适用于 HttpWebhook 和 ApiConnectionWebhook 连接器类型的触发器和作，但不适用于 手动、 定期、 HTTP 和 APIConnection 类型。

listCallbackUrl()

示例

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

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

M

最大值

返回列表或数组中的最大值，其中包含两端包含的数字。

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

示例

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

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

并返回以下结果： 3

分钟

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

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。 如果表达式为 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。

nthIndexOf

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

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

Examples

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，则返回 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。

输出

在运行时返回作的输出。

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.chinacloudsites.cn",
    "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

返回工作流定义中介绍的参数的值。

parameters('<parameterName>')

示例

假设你具有以下 JSON 值：

{
  "fullName": "Sophia Owen"
}

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

parameters('fullName')

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

parseDateTime

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

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

Examples

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或 34

范围

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

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

此示例从 customerName JSON 对象的父属性中删除middleName子属性，该属性通过使用 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>')

示例

本示例在“旧字符串”中找到“old”子字符串，并将“old”替换为“new”：

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

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

结果

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

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

result('<scopedActionName>')

示例

此示例通过使用result()作中的Compose函数返回循环中 For_each 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"
            }
         }
      ]
   }
]

反向

反转集合中项的顺序。 将此函数用于 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

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

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

下面是当前的 JSON 对象：

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

下面是更新的 JSON 对象：

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

示例 2

此示例设置 surName JSON 对象中父属性的 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]

切分

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

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

Examples

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" }')]

拆分

返回一个数组，该数组包含子字符串，用逗号分隔，基于原始字符串中的指定分隔符字符。

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"

以...开始

检查字符串是否以特定的子字符串开头。 找到子字符串时返回 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(<minuend>, <subtrahend>)

示例

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

sub(10.3, .3)

并返回以下结果： 10

substring

从指定位置或索引开始返回字符串中的字符。 索引值以数字 0 开头。 另请参阅切片（）。

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

示例

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

substring('hello world', 6, 5)

并返回以下结果： "world"

subtractFromTime

从时间戳中减去一些时间单位。 另请参阅 getPastTime。

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

示例 1

此示例从此时间戳中减去一天：

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

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

示例 2

此示例从此时间戳中减去一天：

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

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

T

拿

从集合的前面返回项。

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

示例

这些示例从这些集合的前面获取指定的项数：

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

并返回以下结果：

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

蜱

返回自 0001 年 1 月 1 日 12：00：00：00 午夜（或 C# 中的 DateTime.Ticks）以来的 100 纳秒间隔的时钟周期数（或 C# 中的 DateTime.Ticks）。 有关详细信息，请参阅本主题：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 请参阅触发器（）。

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 请参阅触发器（）。

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

返回 host 统一资源标识符（URI）的值。

uriHost('<uri>')

示例

此示例查找 host 此 URI 的值：

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

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

uriPath

返回 path 统一资源标识符（URI）的值。

uriPath('<uri>')

示例

此示例查找 path 此 URI 的值：

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

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

uriPathAndQuery

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

uriPathAndQuery('<uri>')

示例

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

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

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

uriPort

返回 port 统一资源标识符（URI）的值。

uriPort('<uri>')

示例

此示例返回 port 此 URI 的值：

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

并返回以下结果： 8080

uriQuery

返回 query 统一资源标识符（URI）的值。

uriQuery('<uri>')

示例

此示例返回 query 此 URI 的值：

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

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

uriScheme

返回 scheme 统一资源标识符（URI）的值。

uriScheme('<uri>')

示例

此示例返回 scheme 此 URI 的值：

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

并返回以下结果： "http"

utcNow

返回当前时间戳。

utcNow('<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

此示例为此字符串创建 XML 版本，其中包含 JSON 对象：

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()'，查找与 XML 字符串中的节点匹配 <name></name> 的 '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]'，查找具有expired该属性的所有name元素：

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]'以查找具有以下price > 35所有元素的name元素：

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

下面是结果： Honeycrisp

示例 7

在此示例中，假设 XML items 字符串与示例 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

后续步骤

了解 工作流定义语言