Funções de matriz para modelos do ARM

Este artigo descreve as funções modelo para trabalhar com matrizes.

Para obter uma matriz de valores de cadeia de caracteres delimitada por um valor, confira split.

matriz

array(convertToArray)

Converte o valor em uma matriz.

No Bicep, use a array função.

Parâmetros

Retornar valor

Uma matriz .

Exemplo

O exemplo a seguir mostra como usar a array função com tipos diferentes:

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

A saída dos valores padrão do exemplo anterior é:

concat

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

Combina várias matrizes e retorna a matriz concatenada, ou combina vários valores de cadeia de caracteres e retorna a matriz concatenada.

No Bicep, use a concat função.

Parâmetros

Essa função pode usar qualquer número de argumentos e pode aceitar cadeias de caracteres ou matrizes para os parâmetros. No entanto, você não pode apresentar cadeias de caracteres e matrizes para parâmetros. Só é possível concatenar matrizes com outras matrizes.

Retornar valor

Uma cadeia de caracteres ou matriz de valores concatenados.

Exemplo

O exemplo a seguir mostra como combinar duas matrizes:

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

A saída dos valores padrão do exemplo anterior é:

O exemplo a seguir mostra como combinar dois valores de cadeia de caracteres e retornar uma cadeia de caracteres concatenada:

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

A saída dos valores padrão do exemplo anterior é:

contém

contains(container, itemToFind)

Verifica se uma matriz contém um valor, um objeto contém uma chave ou uma cadeia de caracteres contém uma subcadeia de caracteres. A comparação de cadeia de caracteres diferencia maiúsculas de minúsculas. No entanto, ao testar se um objeto contém uma chave, a comparação não diferencia maiúsculas de minúsculas.

No Bicep, use a contains função.

Parâmetros

Retornar valor

True se o item for encontrado; caso contrário, False.

Exemplo

O exemplo a seguir mostra como usar contains com tipos diferentes:

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

A saída dos valores padrão do exemplo anterior é:

criar matriz

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

Cria uma matriz de parâmetros.

Não há suporte para a função createArray no Bicep. Para construir uma matriz, consulte o tipo de dados array no Bicep.

Parâmetros

Retornar valor

Uma matriz . Quando nenhum parâmetro é fornecido, ele retorna uma matriz vazia.

Exemplo

O exemplo a seguir mostra como usar createArray com tipos diferentes:

{
  "$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()]"
    }
  }
}

A saída dos valores padrão do exemplo anterior é:

vazio

empty(itemToTest)

Determina se uma matriz, objeto ou uma cadeia de caracteres está vazio.

No Bicep, use a empty função.

Parâmetros

Retornar valor

Retorna True se o valor é vazio; caso contrário, False.

Exemplo

O exemplo a seguir verifica se uma matriz, um objeto e uma cadeia de caracteres estão vazios:

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

A saída dos valores padrão do exemplo anterior é:

primeiro

first(arg1)

Retorna o primeiro elemento da matriz ou o primeiro caractere da cadeia de caracteres.

No Bicep, use a first função.

Parâmetros

Retornar valor

O tipo (cadeia de caracteres, inteiro, matriz ou objeto) do primeiro elemento em uma matriz ou o primeiro caractere de uma cadeia de caracteres.

Exemplo

O exemplo a seguir mostra como usar a first função com uma matriz e uma cadeia de caracteres:

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

A saída dos valores padrão do exemplo anterior é:

indexFromEnd

indexFromEnd(sourceArray, reverseIndex)

Retorna um elemento da matriz contando para trás do final. Isso é útil quando você deseja referenciar elementos a partir do final de uma lista em vez do início. A tryIndexFromEnd função é uma versão segura de indexFromEnd.

No Bicep, use o operador acessador de índice reservado .

Parâmetros

Retornar valor

Um único elemento de uma matriz, selecionado contando para trás do final da matriz.

Exemplo

O exemplo a seguir mostra como usar a função indexFromEnd:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "items": [
      "apple",
      "banana",
      "orange",
      "grape"
    ]
  },
  "resources": [],
  "outputs": {
    "secondToLast": {
      "type": "string",
      "value": "[indexFromEnd(variables('items'), 2)]"
    }
  }
}

A saída dos valores padrão do exemplo anterior é:

indexOf

indexOf(arrayToSearch, itemToFind)

Retorna um inteiro para o índice da primeira ocorrência de um item em uma matriz. A comparação diferencia maiúsculas de minúsculas nas cadeias de caracteres.

Parâmetros

Retornar valor

Um inteiro que representa o primeiro índice do item na matriz. O índice começa no zero. Se o item não for encontrado, -1 será retornado.

Exemplos

O exemplo a seguir mostra como usar as funções indexOf e 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)]"
    }
  }
}

O resultado do exemplo anterior é:

interseção

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

Retorna uma única matriz ou objeto com os elementos comuns dos parâmetros.

No Bicep, use a intersection função.

Parâmetros

Retornar valor

Uma matriz ou objeto com os elementos comuns.

Exemplo

O exemplo a seguir mostra como usar intersection com matrizes e objetos:

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

A saída dos valores padrão do exemplo anterior é:

último

last(arg1)

Retorna o último elemento da matriz ou o último caractere da cadeia de caracteres.

No Bicep, use a last função.

Parâmetros

Retornar valor

O tipo (cadeia de caracteres, inteiro, matriz ou objeto) do último elemento em uma matriz ou o último caractere de uma cadeia de caracteres.

Exemplo

O exemplo a seguir mostra como usar a last função com uma matriz e uma cadeia de caracteres:

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

A saída dos valores padrão do exemplo anterior é:

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

Retorna um inteiro para o índice da última ocorrência de um item em uma matriz. A comparação diferencia maiúsculas de minúsculas nas cadeias de caracteres.

Parâmetros

Retornar valor

Um inteiro que representa o último índice do item na matriz. O índice começa no zero. Se o item não for encontrado, -1 será retornado.

Exemplos

O exemplo a seguir mostra como usar as funções indexOf e 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)]"
    }
  }
}

O resultado do exemplo anterior é:

comprimento

length(arg1)

Retorna o número de elementos de uma matriz, caracteres de uma cadeia de caracteres ou propriedades em nível raiz de um objeto.

No Bicep, use a length função.

Parâmetros

Retornar valor

Um inteiro.

Exemplo

O exemplo a seguir mostra como usar length com uma matriz e uma cadeia de caracteres:

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

A saída dos valores padrão do exemplo anterior é:

Essa função pode ser usada com uma matriz para especificar o número de iterações durante a criação de recursos. No exemplo a seguir, o site de parâmetrosNames refere-se a uma matriz de nomes a serem usados ao criar sites:

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

Para obter mais informações sobre como usar essa função com uma matriz, veja Iteração de recurso em modelos do ARM.

máximo

max(arg1)

Retorna o valor máximo de uma matriz de inteiros ou uma lista de inteiros separados por vírgulas.

No Bicep, use a max função.

Parâmetros

Retornar valor

Um inteiro que representa o valor máximo.

Exemplo

O exemplo a seguir mostra como usar max com uma matriz e uma lista de inteiros:

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

A saída dos valores padrão do exemplo anterior é:

minutos

min(arg1)

Retorna o valor mínimo de uma matriz de inteiros ou uma lista de inteiros separados por vírgulas.

No Bicep, use a min função.

Parâmetros

Retornar valor

Um inteiro que representa o valor mínimo.

Exemplo

O exemplo a seguir mostra como usar min com uma matriz e uma lista de inteiros:

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

A saída dos valores padrão do exemplo anterior é:

alcance

range(startIndex, count)

Cria uma matriz de inteiros a partir de um inteiro inicial e contendo um número de itens.

No Bicep, use a range função.

Parâmetros

Retornar valor

Uma matriz de inteiros.

Exemplo

O exemplo a seguir mostra como usar a função 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'))]"
    }
  }
}

A saída dos valores padrão do exemplo anterior é:

ignorar

skip(originalValue, numberToSkip)

Retorna uma matriz com todos os elementos após o número especificado na matriz, ou retorna uma cadeia de caracteres com todos os caracteres após o número especificado na cadeia de caracteres.

No Bicep, use a skip função.

Parâmetros

Retornar valor

Uma matriz ou cadeia de caracteres.

Exemplo

O exemplo a seguir ignora o número especificado de elementos na matriz e o número especificado de caracteres em uma cadeia de caracteres:

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

A saída dos valores padrão do exemplo anterior é:

tomar

take(originalValue, numberToTake)

Retorna uma matriz de cadeias de caracteres. Uma matriz com o número especificado de elementos desde o início da matriz. Uma cadeia de caracteres com o número especificado de caracteres no início da cadeia.

No Bicep, use a take função.

Parâmetros

Retornar valor

Uma matriz ou cadeia de caracteres.

Exemplo

O exemplo a seguir usa o número especificado de elementos de uma matriz e caracteres de uma cadeia de caracteres:

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

A saída dos valores padrão do exemplo anterior é:

tryGet

tryGet(itemToTest, keyOrIndex)

tryGet ajuda você a evitar falhas de implantação ao tentar acessar uma propriedade ou índice inexistente em um objeto ou matriz. Se a chave ou índice especificado não existir, tryGet retornará nulo em vez de gerar um erro.

No Bicep, use o operador de desreferência segura .

Parâmetros

Retornar valor

Retorna o valor na chave/índice se ele existir. Retornará nulo se a chave/índice estiver ausente ou fora dos limites.

Exemplo

O exemplo a seguir verifica se uma matriz, um objeto e uma cadeia de caracteres estão vazios:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "languageVersion": "2.0",
  "contentVersion": "1.0.0.0",
  "variables": {
    "users": {
      "name": "John Doe",
      "age": 30
    },
    "colors": [
      "red",
      "green"
    ]
  },
  "resources": [],
  "outputs": {
    "region": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('users'), 'region')]"
    },
    "name": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('users'), 'name')]"
    },
    "firstColor": {
      "type": "string",
      "nullable": true,
      "value": "[tryGet(variables('colors'), 0)]"
    }
  }
}

O resultado do exemplo anterior é:

tryIndexFromEnd

tryndexFromEnd(sourceArray, reverseIndex)

A tryIndexFromEnd função é uma versão segura de indexFromEnd. Ele recupera um valor de uma matriz contando para trás do final sem gerar um erro se o índice estiver fora do intervalo.

No Bicep, use o operador acessador de índice reservado e o operador de desreferência segura .

Parâmetros

Retornar valor

Se o índice for válido (dentro dos limites da matriz), retornará o elemento de matriz nesse índice inverso. Se o índice estiver fora do intervalo, retornará nulo em vez de gerar um erro.

Exemplo

O exemplo a seguir mostra como usar a função tryIndexFromEnd:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "items": [
      "apple",
      "banana",
      "orange",
      "grape"
    ]
  },
  "resources": [],
  "outputs": {
    "secondToLast": {
      "type": "string",
      "value": "[tryIndexFromEnd(variables('items'), 2)]"
    }
  }
}

A saída dos valores padrão do exemplo anterior é:

O exemplo a seguir mostra um cenário fora do limite:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "languageVersion": "2.0",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "items": {
      "type": "array",
      "defaultValue": [
        "apple",
        "banana",
        "orange",
        "grape"
      ]
    }
  },
  "resources": {},
  "outputs": {
    "outOfBound": {
      "type": "string",
      "nullable": true,
      "value": "[tryIndexFromEnd(parameters('items'), 5)]"
    }
  }
}

A saída dos valores padrão do exemplo anterior é:

união

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

Retorna uma única matriz ou objeto com todos os elementos dos parâmetros. Para matrizes, os valores duplicados são incluídos uma vez. Para objetos, os nomes de propriedades duplicados são incluídos apenas uma vez.

No Bicep, use a union função.

Parâmetros

Retornar valor

Uma matriz ou objeto.

Comentários

O union function usa a sequência dos parâmetros para determinar a ordem e os valores do resultado.

Para matrizes, a função itera através de cada elemento no primeiro parâmetro e o adiciona ao resultado se ainda não estiver presente. Em seguida, ele repete o processo para o segundo parâmetro e quaisquer parâmetros adicionais. Se um valor já estiver presente, o posicionamento anterior na matriz será preservado.

Para objetos, nomes de propriedades e valores do primeiro parâmetro são adicionados ao resultado. Para parâmetros posteriores, todos os novos nomes são adicionados ao resultado. Se um parâmetro posterior tiver uma propriedade com o mesmo nome, esse valor substituirá o valor existente. A ordem das propriedades não é garantida.

A union função não só mescla os elementos de nível superior, mas também mescla recursivamente quaisquer objetos aninhados dentro deles. Os valores da matriz aninhada não são mesclados. Veja o segundo exemplo na seção a seguir.

Exemplo

O exemplo a seguir mostra como usar union com matrizes e objetos:

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

A saída dos valores padrão do exemplo anterior é:

O exemplo a seguir mostra a capacidade de mesclagem profunda:

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

O resultado do exemplo anterior é:

Se matrizes aninhadas foram mescladas, o valor de objectOutput.nestedArray será [1, 2, 3, 4], e o valor de arrayOutput será [["one", "two", "three"], ["three", "four", "two"]].

Próximas etapas

• Para obter uma descrição das seções de um modelo do ARM, confira Entender a estrutura e a sintaxe dos modelos do ARM.