ARM 模板的数组函数

项目
02/28/2024

本文介绍用于处理数组的模板函数。

若要获取由某个值分隔的字符串值数组，请参阅 split。

提示

我们建议使用 Bicep，因为它提供与 ARM 模板相同的功能，并且该语法更易于使用。有关详细信息，请参阅 array 函数。

array

array(convertToArray)

将值转换为数组。

在 Bicep 中，使用 array 函数。

参数

参数	必选	类型	说明
convertToArray	是	整数、字符串、数组或对象	要转换为数组的值。

返回值

一个数组。

示例

以下示例演示如何对不同的类型使用 array 函数。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "intToConvert": {
      "type": "int",
      "defaultValue": 1
    },
    "stringToConvert": {
      "type": "string",
      "defaultValue": "efgh"
    },
    "objectToConvert": {
      "type": "object",
      "defaultValue": {
        "a": "b",
        "c": "d"
      }
    }
  },
  "resources": [
  ],
  "outputs": {
    "intOutput": {
      "type": "array",
      "value": "[array(parameters('intToConvert'))]"
    },
    "stringOutput": {
      "type": "array",
      "value": "[array(parameters('stringToConvert'))]"
    },
    "objectOutput": {
      "type": "array",
      "value": "[array(parameters('objectToConvert'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	Value
intOutput	Array	[1]
stringOutput	Array	["efgh"]
objectOutput	Array	[{"a": "b", "c": "d"}]

concat

concat(arg1, arg2, arg3, ...)

合并多个数组并返回串联的数组，或合并多个字符串值并返回串联的字符串。

在 Bicep 中，使用 concat 函数。

参数

参数	必选	类型	说明
arg1	是	数组或字符串	要串联的第一个数组或字符串。
其他参数	否	数组或字符串	按顺序排列要进行串联的其他数组或字符串。

此函数可以使用任意数量的参数，并可接受字符串或数组作为参数。但是，不能同时为参数提供数组和字符串。数组仅与其他数组连接。

返回值

由串联值构成的字符串或数组。

示例

以下示例演示如何组合两个数组。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "firstArray": {
      "type": "array",
      "defaultValue": [
        "1-1",
        "1-2",
        "1-3"
      ]
    },
    "secondArray": {
      "type": "array",
      "defaultValue": [
        "2-1",
        "2-2",
        "2-3"
      ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "return": {
      "type": "array",
      "value": "[concat(parameters('firstArray'), parameters('secondArray'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
return	Array	["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"]

以下示例演示如何组合两个字符串值并返回串联的字符串。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "prefix": {
      "type": "string",
      "defaultValue": "prefix"
    }
  },
  "resources": [],
  "outputs": {
    "concatOutput": {
      "type": "string",
      "value": "[concat(parameters('prefix'), '-', uniqueString(resourceGroup().id))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
concatOutput	String	prefix-5yj4yjf5mbg72

contains

contains(container, itemToFind)

检查数组是否包含某个值、某个对象是否包含某个键，或者某个字符串是否包含某个子字符串。字符串比较区分大小写。但在测试某个对象是否包含某个键时，该比较不区分大小写。

在 Bicep 中，使用 contains 函数。

参数

参数	必选	类型	说明
container	是	数组、对象或字符串	包含要查找的值的值。
itemToFind	是	字符串或整数	要查找的值。

返回值

如果找到该项，则为 True；否则为 False。

示例

以下示例演示如何对不同的类型使用 contains：

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "stringToTest": {
      "type": "string",
      "defaultValue": "OneTwoThree"
    },
    "objectToTest": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c"
      }
    },
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "stringTrue": {
      "type": "bool",
      "value": "[contains(parameters('stringToTest'), 'e')]"
    },
    "stringFalse": {
      "type": "bool",
      "value": "[contains(parameters('stringToTest'), 'z')]"
    },
    "objectTrue": {
      "type": "bool",
      "value": "[contains(parameters('objectToTest'), 'one')]"
    },
    "objectFalse": {
      "type": "bool",
      "value": "[contains(parameters('objectToTest'), 'a')]"
    },
    "arrayTrue": {
      "type": "bool",
      "value": "[contains(parameters('arrayToTest'), 'three')]"
    },
    "arrayFalse": {
      "type": "bool",
      "value": "[contains(parameters('arrayToTest'), 'four')]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
stringTrue	Bool	True
stringFalse	Bool	False
objectTrue	Bool	True
objectFalse	Bool	False
arrayTrue	Bool	True
arrayFalse	Bool	False

createArray

createArray(arg1, arg2, arg3, ...)

从参数创建数组。

在 Bicep 中，不支持 createArray 函数。若要构造数组，请参阅 Bicep array 数据类型。

参数

参数	必选	类型	说明
args	否	字符串、整数、数组或对象	数组中的值。

返回值

一个数组。如果未提供任何参数，它会返回空数组。

示例

以下示例演示如何对不同的类型使用 createArray：

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "objectToTest": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c"
      }
    },
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "stringArray": {
      "type": "array",
      "value": "[createArray('a', 'b', 'c')]"
    },
    "intArray": {
      "type": "array",
      "value": "[createArray(1, 2, 3)]"
    },
    "objectArray": {
      "type": "array",
      "value": "[createArray(parameters('objectToTest'))]"
    },
    "arrayArray": {
      "type": "array",
      "value": "[createArray(parameters('arrayToTest'))]"
    },
    "emptyArray": {
      "type": "array",
      "value": "[createArray()]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	Value
stringArray	Array	["a", "b", "c"]
intArray	Array	[1, 2, 3]
objectArray	Array	[{"one": "a", "two": "b", "three": "c"}]
arrayArray	Array	[["one", "two", "three"]]
emptyArray	Array	[]

empty

empty(itemToTest)

确定数组、对象或字符串是否为空。

在 Bicep 中，使用 empty 函数。

参数

参数	必选	类型	说明
itemToTest	是	数组、对象或字符串	要检查是否为空的值。

返回值

如果该值为空，则返回 True；否则返回 False。

示例

以下示例检查某个数组、对象和字符串是否为空。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "testArray": {
      "type": "array",
      "defaultValue": []
    },
    "testObject": {
      "type": "object",
      "defaultValue": {}
    },
    "testString": {
      "type": "string",
      "defaultValue": ""
    }
  },
  "resources": [
  ],
  "outputs": {
    "arrayEmpty": {
      "type": "bool",
      "value": "[empty(parameters('testArray'))]"
    },
    "objectEmpty": {
      "type": "bool",
      "value": "[empty(parameters('testObject'))]"
    },
    "stringEmpty": {
      "type": "bool",
      "value": "[empty(parameters('testString'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayEmpty	Bool	True
objectEmpty	Bool	True
stringEmpty	Bool	True

first

first(arg1)

返回数组的第一个元素，或字符串的第一个字符。

在 Bicep 中，使用 first 函数。

参数

参数	必选	类型	说明
arg1	是	数组或字符串	要检索第一个元素或字符的值。

返回值

数组中第一个元素的类型（字符串、整数、数组或对象），或者字符串的第一个字符。

示例

以下示例演示如何对不同的类型使用 first 函数。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "arrayOutput": {
      "type": "string",
      "value": "[first(parameters('arrayToTest'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[first('One Two Three')]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayOutput	String	one
stringOutput	String	O

indexOf

indexOf(arrayToSearch, itemToFind)

返回数组中第一次出现的项的索引的整数。字符串比较区分大小写。

参数

参数	必选	类型	说明
arrayToSearch	是	array	用于查找所搜索项索引的数组。
itemToFind	是	整数、字符串、数组或对象	要在数组中查找的项。

返回值

一个整数，表示数组中项的第一个索引。该索引从零开始。如果未找到该项，则返回 -1。

示例

以下示例演示如何使用 indexOf 和 lastIndexOf 函数：

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "names": [
      "one",
      "two",
      "three"
    ],
    "numbers": [
      4,
      5,
      6
    ],
    "collection": [
      "[variables('names')]",
      "[variables('numbers')]"
    ],
    "duplicates": [
      1,
      2,
      3,
      1
    ]
  },
  "resources": [],
  "outputs": {
    "index1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'two')]"
    },
    "index2": {
      "type": "int",
      "value": "[indexOf(variables('names'), 'one')]"
    },
    "notFoundIndex1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'Three')]"
    },
    "index3": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), 4)]"
    },
    "index4": {
      "type": "int",
      "value": "[indexOf(variables('numbers'), 6)]"
    },
    "notFoundIndex2": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), '5')]"
    },
    "index5": {
      "type": "int",
      "value": "[indexOf(variables('collection'), variables('numbers'))]"
    },
    "index6": {
      "type": "int",
      "value": "[indexOf(variables('duplicates'), 1)]"
    },
    "index7": {
      "type": "int",
      "value": "[lastIndexOf(variables('duplicates'), 1)]"
    }
  }
}

前述示例的输出为：

名称	类型	值
index1	int	1
index2	int	0
index3	int	0
index4	int	2
index5	int	1
index6	int	0
index7	int	3
notFoundIndex1	int	-1
notFoundIndex2	int	-1

intersection

intersection(arg1, arg2, arg3, ...)

返回包含参数中通用元素的单个数组或对象。

在 Bicep 中，使用 intersection 函数。

参数

参数	必选	类型	说明
arg1	是	数组或对象	用于查找通用元素的第一个值。
arg2	是	数组或对象	用于查找通用元素的第二个值。
其他参数	否	数组或对象	用于查找通用元素的其他值。

返回值

包含通用元素的数组或对象。

示例

以下示例演示如何对数组和对象使用 intersection。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "firstObject": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c"
      }
    },
    "secondObject": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "z",
        "three": "c"
      }
    },
    "firstArray": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    },
    "secondArray": {
      "type": "array",
      "defaultValue": [ "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "objectOutput": {
      "type": "object",
      "value": "[intersection(parameters('firstObject'), parameters('secondObject'))]"
    },
    "arrayOutput": {
      "type": "array",
      "value": "[intersection(parameters('firstArray'), parameters('secondArray'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
objectOutput	对象	{"one": "a", "three": "c"}
arrayOutput	Array	["two", "three"]

last

last(arg1)

返回数组的最后一个元素，或字符串的最后一个字符。

在 Bicep 中，使用 last 函数。

参数

参数	必选	类型	说明
arg1	是	数组或字符串	要检索最后一个元素或字符的值。

返回值

数组中最后一个元素的类型（字符串、整数、数组或对象），或者字符串的最后一个字符。

示例

以下示例演示如何对不同的类型使用 last 函数。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "arrayOutput": {
      "type": "string",
      "value": "[last(parameters('arrayToTest'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[last('One Two Three')]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayOutput	String	three
stringOutput	String	e

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

返回数组中最后一次出现的项的索引的整数。字符串比较区分大小写。

参数

参数	必选	类型	说明
arrayToSearch	是	array	用于查找所搜索项索引的数组。
itemToFind	是	整数、字符串、数组或对象	要在数组中查找的项。

返回值

一个整数，表示数组中项的最后一个索引。该索引从零开始。如果未找到该项，则返回 -1。

示例

以下示例演示如何使用 indexOf 和 lastIndexOf 函数：

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "names": [
      "one",
      "two",
      "three"
    ],
    "numbers": [
      4,
      5,
      6
    ],
    "collection": [
      "[variables('names')]",
      "[variables('numbers')]"
    ],
    "duplicates": [
      1,
      2,
      3,
      1
    ]
  },
  "resources": [],
  "outputs": {
    "index1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'two')]"
    },
    "index2": {
      "type": "int",
      "value": "[indexOf(variables('names'), 'one')]"
    },
    "notFoundIndex1": {
      "type": "int",
      "value": "[lastIndexOf(variables('names'), 'Three')]"
    },
    "index3": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), 4)]"
    },
    "index4": {
      "type": "int",
      "value": "[indexOf(variables('numbers'), 6)]"
    },
    "notFoundIndex2": {
      "type": "int",
      "value": "[lastIndexOf(variables('numbers'), '5')]"
    },
    "index5": {
      "type": "int",
      "value": "[indexOf(variables('collection'), variables('numbers'))]"
    },
    "index6": {
      "type": "int",
      "value": "[indexOf(variables('duplicates'), 1)]"
    },
    "index7": {
      "type": "int",
      "value": "[lastIndexOf(variables('duplicates'), 1)]"
    }
  }
}

前述示例的输出为：

名称	类型	值
index1	int	1
index2	int	0
index3	int	0
index4	int	2
index5	int	1
index6	int	0
index7	int	3
notFoundIndex1	int	-1
notFoundIndex2	int	-1

length

length(arg1)

返回数组中的元素数、字符串中的字符数或对象中的根级属性数。

在 Bicep 中，使用 length 函数。

参数

参数	必选	类型	说明
arg1	是	数组、字符串或对象	用于获取元素数的数组、用于获取字符数的字符串，或用于获取根级属性数的对象。

返回值

一个整数。

示例

以下示例演示如何对数组和字符串使用 length。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [
        "one",
        "two",
        "three"
      ]
    },
    "stringToTest": {
      "type": "string",
      "defaultValue": "One Two Three"
    },
    "objectToTest": {
      "type": "object",
      "defaultValue": {
        "propA": "one",
        "propB": "two",
        "propC": "three",
        "propD": {
          "propD-1": "sub",
          "propD-2": "sub"
        }
      }
    }
  },
  "resources": [],
  "outputs": {
    "arrayLength": {
      "type": "int",
      "value": "[length(parameters('arrayToTest'))]"
    },
    "stringLength": {
      "type": "int",
      "value": "[length(parameters('stringToTest'))]"
    },
    "objectLength": {
      "type": "int",
      "value": "[length(parameters('objectToTest'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayLength	int	3
stringLength	int	13
objectLength	int	4

创建资源时，可在数组中使用此函数指定迭代数。在以下示例中，参数 siteNames 引用创建网站时要使用的名称数组。

"copy": {
  "name": "websitescopy",
  "count": "[length(parameters('siteNames'))]"
}

若要详细了解如何将此函数与数组配合使用，请参阅 ARM 模板中的资源迭代。

max

max(arg1)

返回整数数组或逗号分隔的整数列表中的最大值。

在 Bicep 中，使用 max 函数。

参数

参数	必选	类型	说明
arg1	是	整数数组或逗号分隔的整数列表	要获取最大值的集合。

返回值

表示最大值的整数。

示例

以下示例演示如何对整数数组和整数列表使用 max。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ 0, 3, 2, 5, 4 ]
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "int",
      "value": "[max(parameters('arrayToTest'))]"
    },
    "intOutput": {
      "type": "int",
      "value": "[max(0,3,2,5,4)]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayOutput	int	5
intOutput	int	5

min

min(arg1)

返回整数数组或逗号分隔的整数列表中的最小值。

在 Bicep 中，使用 min 函数。

参数

参数	必选	类型	说明
arg1	是	整数数组或逗号分隔的整数列表	要获取最小值的集合。

返回值

表示最小值的整数。

示例

以下示例演示如何对整数数组和整数列表使用 min。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "arrayToTest": {
      "type": "array",
      "defaultValue": [ 0, 3, 2, 5, 4 ]
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "int",
      "value": "[min(parameters('arrayToTest'))]"
    },
    "intOutput": {
      "type": "int",
      "value": "[min(0,3,2,5,4)]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayOutput	int	0
intOutput	int	0

range

range(startIndex, count)

从起始整数创建整数数组并包含一些项。

在 Bicep 中，使用 range 函数。

参数

参数	必选	类型	说明
startIndex	是	int	数组中的第一个整数。 startIndex 和 count 的总和不得大于 2147483647。
count	是	int	数组中的整数个数。必须为非负整数，最大为 10000。

返回值

整数数组。

示例

以下示例演示如何使用 range 函数。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "startingInt": {
      "type": "int",
      "defaultValue": 5
    },
    "numberOfElements": {
      "type": "int",
      "defaultValue": 3
    }
  },
  "resources": [],
  "outputs": {
    "rangeOutput": {
      "type": "array",
      "value": "[range(parameters('startingInt'),parameters('numberOfElements'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	Value
rangeOutput	Array	[5, 6, 7]

skip

skip(originalValue, numberToSkip)

返回一个数组，其中包含数组中指定数字后面的所有元素；或返回一个字符串，其中包含字符串中指定数后面的所有字符。

在 Bicep 中，使用 skip 函数。

参数

参数	必选	类型	说明
originalValue	是	数组或字符串	用于跳过的数组或字符串。
numberToSkip	是	int	要跳过的元素数或字符数。如果此值小于或等于 0，则返回值中的所有元素或字符。如果此值大于数组或字符串的长度，则返回空数组或字符串。

返回值

数组或字符串。

示例

以下示例跳过数组中指定数目的元素，以及字符串中指定数目的字符。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "testArray": {
      "type": "array",
      "defaultValue": [
        "one",
        "two",
        "three"
      ]
    },
    "elementsToSkip": {
      "type": "int",
      "defaultValue": 2
    },
    "testString": {
      "type": "string",
      "defaultValue": "one two three"
    },
    "charactersToSkip": {
      "type": "int",
      "defaultValue": 4
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "array",
      "value": "[skip(parameters('testArray'),parameters('elementsToSkip'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[skip(parameters('testString'),parameters('charactersToSkip'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayOutput	Array	["three"]
stringOutput	String	two three

take

take(originalValue, numberToTake)

返回数组或字符串。数组包含指定数目的元素（从数组开头算起）。字符串包含指定数目的字符（从字符串开头算起）。

在 Bicep 中，使用 take 函数。

参数

参数	必选	类型	说明
originalValue	是	数组或字符串	要从中提取元素的数组或字符串。
numberToTake	是	int	要提取的元素或字符数。如果此值为 0 或更小，则返回一个空数组或字符串。如果此值大于给定数组或字符串的长度，则返回数组或字符串中的所有元素。

返回值

数组或字符串。

示例

以下示例从数组中提取指定数目的元素，并从字符串中提取指定数目的字符。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "testArray": {
      "type": "array",
      "defaultValue": [
        "one",
        "two",
        "three"
      ]
    },
    "elementsToTake": {
      "type": "int",
      "defaultValue": 2
    },
    "testString": {
      "type": "string",
      "defaultValue": "one two three"
    },
    "charactersToTake": {
      "type": "int",
      "defaultValue": 2
    }
  },
  "resources": [],
  "outputs": {
    "arrayOutput": {
      "type": "array",
      "value": "[take(parameters('testArray'),parameters('elementsToTake'))]"
    },
    "stringOutput": {
      "type": "string",
      "value": "[take(parameters('testString'),parameters('charactersToTake'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
arrayOutput	Array	["one", "two"]
stringOutput	String	on

union

union(arg1, arg2, arg3, ...)

返回包含参数中所有元素的单个数组或对象。对于数组，仅包含重复值一次。对于对象，仅包含重复属性名称一次。

在 Bicep 中，使用 union 函数。

参数

参数	必选	类型	说明
arg1	是	数组或对象	用于联接元素的第一个值。
arg2	是	数组或对象	用于联接元素的第二个值。
其他参数	否	数组或对象	用于联接元素的其他值。

返回值

数组或对象。

备注

联合函数使用参数序列来确定结果的顺序和值。

对于数组，该函数会循环访问第一个参数中的每个元素，并将其添加到结果中（如果尚不存在）。然后，对第二个参数和任何附加参数重复该过程。如果某个值已存在，则保留其此前在数组中的放置位置。

对于对象，来自第一个参数的属性名称和值将添加到结果中。对于稍后的参数，任何新名称都将添加到结果中。如果稍后的参数具有同名的属性，该值将覆盖现有值。不保证属性的顺序。

联合函数不仅合并顶级元素，而且还以递归方式合并其中的嵌套对象。嵌套数组值不会合并。请参阅以下部分中的第二个示例。

示例

以下示例演示如何对数组和对象使用 union。

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "firstObject": {
      "type": "object",
      "defaultValue": {
        "one": "a",
        "two": "b",
        "three": "c1"
      }
    },
    "secondObject": {
      "type": "object",
      "defaultValue": {
        "three": "c2",
        "four": "d",
        "five": "e"
      }
    },
    "firstArray": {
      "type": "array",
      "defaultValue": [ "one", "two", "three" ]
    },
    "secondArray": {
      "type": "array",
      "defaultValue": [ "three", "four" ]
    }
  },
  "resources": [
  ],
  "outputs": {
    "objectOutput": {
      "type": "object",
      "value": "[union(parameters('firstObject'), parameters('secondObject'))]"
    },
    "arrayOutput": {
      "type": "array",
      "value": "[union(parameters('firstArray'), parameters('secondArray'))]"
    }
  }
}

上述示例中使用默认值的输出为：

名称	类型	值
objectOutput	Object	{"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput	Array	["one", "two", "three", "four"]

以下示例演示了深度合并功能：

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "firstObject": {
      "property": {
        "one": "a",
        "two": "b",
        "three": "c1"
      },
      "nestedArray": [
        1,
        2
      ]
    },
    "secondObject": {
      "property": {
        "three": "c2",
        "four": "d",
        "five": "e"
      },
      "nestedArray": [
        3,
        4
      ]
    },
    "firstArray": [
      [
        "one",
        "two"
      ],
      [
        "three"
      ]
    ],
    "secondArray": [
      [
        "three"
      ],
      [
        "four",
        "two"
      ]
    ]
  },
  "resources": [],
  "outputs": {
    "objectOutput": {
      "type": "Object",
      "value": "[union(variables('firstObject'), variables('secondObject'))]"
    },
    "arrayOutput": {
      "type": "Array",
      "value": "[union(variables('firstArray'), variables('secondArray'))]"
    }
  }
}

前述示例的输出为：

名称	类型	值
objectOutput	Object	{"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]}
arrayOutput	数组	[["one","two"],["three"],["four","two"]]

如果合并了嵌套数组，则 objectOutput.nestedArray 的值将为 [1, 2, 3, 4]，arrayOutput 的值将为 [["one", "two", "three"], ["three", "four", "two"]]。

后续步骤

有关 ARM 模板中各部分的说明，请参阅了解 ARM 模板的结构和语法。

通过

ARM 模板的数组函数

array

参数

返回值

示例

concat

参数

返回值

示例

contains

参数

返回值

示例

createArray

参数

返回值

示例

empty

参数

返回值

示例

first

参数

返回值

示例

indexOf

参数

返回值

示例

intersection

参数

返回值

示例

last

参数

返回值

示例

lastIndexOf

参数

返回值

示例

length

参数

返回值

示例

max

参数

返回值

示例

min

参数

返回值

示例

range

参数

返回值

示例

skip

参数

返回值

示例

take

参数

返回值

示例

union

参数

返回值

备注

示例

后续步骤

其他资源