Funções de matriz para modelos ARM

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

Para obter uma matriz de valores de cadeia de caracteres delimitada por um valor, consulte dividir.

matriz

array(convertToArray)

Converte o valor em uma matriz.

Em Bicep, use a função array.

Parâmetros

Valor devolvido

Uma matriz.

Exemplo

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

{
  "$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 cadeia de caracteres concatenada.

Em Bicep, use a função concat.

Parâmetros

Esta função pode assumir qualquer número de argumentos e pode aceitar cadeias ou arrays para os parâmetros. No entanto, não é possível fornecer matrizes e cadeias de caracteres para parâmetros. As matrizes são concatenadas apenas com outras matrizes.

Valor devolvido

Uma cadeia de caracteres ou matriz de valores concatenados.

Exemplo

O exemplo seguinte mostra como combinar dois arrays:

{
  "$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 seguinte mostra como combinar dois valores de cadeia e devolver uma cadeia 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 um array contém um valor, um objeto contém uma chave, ou uma cadeia contém uma substring. 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.

Em Bicep, use a função contains.

Parâmetros

Valor devolvido

Verdade se a função encontrar o item; caso contrário, falso.

Exemplo

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

{
  "$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 é:

createArray

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

Cria uma matriz a partir dos parâmetros.

No Bicep, a createArray função não é suportada. Para construir uma matriz, consulte o tipo de dados de matriz Bicep.

Parâmetros

Valor devolvido

Uma matriz. Quando não fornece nenhum parâmetro, devolve um array vazio.

Exemplo

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

{
  "$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 é:

distinct

distinct(arrayToModify)

Retorna um novo array com todos os valores duplicados removidos do array de entrada. A função preserva a ordem original da primeira ocorrência.

Em Bicep, use a função distinct.

Parâmetros

Valor devolvido

Um array contendo apenas elementos únicos do array de entrada. A ordem dos elementos é preservada com base na sua primeira aparição.

Exemplo

O exemplo seguinte mostra como usar a distinct função com diferentes tipos de arrays.

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "numbers": [ 1, 2, 2, 3, 1 ],
    "names": [ "apple", "banana", "apple", "cherry" ],
    "resources": [
      {
        "name": "storage1",
        "type": "Microsoft.Storage/storageAccounts"
      },
      {
        "name": "vm1",
        "type": "Microsoft.Compute/virtualMachines"
      },
      {
        "name": "storage1",
        "type": "Microsoft.Storage/storageAccounts"
      }
    ]
  },
  "outputs": {
    "uniqueNumbers": {
      "type": "array",
      "value": "[distinct(variables('numbers'))]"
    },
    "uniqueNames": {
      "type": "array",
      "value": "[distinct(variables('names'))]"
    },
    "uniqueResources": {
      "type": "array",
      "value": "[distinct(variables('resources'))]"
    }
  }
}

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

vazio

empty(itemToTest)

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

Em Bicep, use a função empty.

Parâmetros

Valor devolvido

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

Exemplo

O exemplo seguinte verifica se um array, objeto e cadeia 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.

Em Bicep, use a função first.

Parâmetros

Valor devolvido

O tipo (string, int, array ou object) do primeiro elemento de uma matriz ou o primeiro caractere de uma cadeia de caracteres.

Exemplo

O exemplo seguinte mostra como usar a first função com um array e uma cadeia:

{
  "$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 a partir do final. Esta função é útil quando se quer referenciar elementos que começam pelo final de uma lista em vez do início. A tryIndexFromEnd função é uma versão segura do indexFromEnd.

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

Parâmetros

Valor devolvido

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

Exemplo

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

{
  "$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 para cadeias de caracteres.

Parâmetros

Valor devolvido

Um inteiro que representa o primeiro índice do item na matriz. O índice é baseado em zero. Se o item não for encontrado, a função devolve -1.

Exemplos

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

A saída do exemplo anterior é:

intersecção

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

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

Em Bicep, use a função intersection.

Parâmetros

Valor devolvido

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.

Em Bicep, use a função last.

Parâmetros

Valor devolvido

O tipo (string, int, array ou object) do último elemento de uma matriz ou o último caractere de uma cadeia de caracteres.

Exemplo

O exemplo seguinte mostra como usar a last função com um array e uma cadeia:

{
  "$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 é:

últimoÍndiceDe

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 para cadeias de caracteres.

Parâmetros

Valor devolvido

Um inteiro que representa o último índice do item na matriz. O índice é baseado em zero. Se o item não for encontrado, -1 será devolvido.

Exemplos

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

A saída do exemplo anterior é:

comprimento

length(arg1)

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

Em Bicep, use a função length.

Parâmetros

Valor devolvido

Um int.

Exemplo

O exemplo seguinte mostra como usar length com um array e uma string:

{
  "$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 é:

Você pode usar essa função com uma matriz para especificar o número de iterações ao criar recursos. No exemplo seguinte, o parâmetro siteNames refere-se a um conjunto de nomes a usar na criação de websites:

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

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

máximo

max(arg1)

Devolve o valor máximo de uma matriz de inteiros ou de uma lista de inteiros separada por vírgula.

Em Bicep, use a função max.

Parâmetros

Valor devolvido

Um int que representa o valor máximo.

Exemplo

O exemplo seguinte mostra como usar max com um array 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 é:

minuto

min(arg1)

Devolve o valor mínimo de uma matriz de inteiros ou de uma lista de inteiros separada por vírgula.

Em Bicep, use a função min.

Parâmetros

Valor devolvido

Um int que representa o valor mínimo.

Exemplo

O exemplo seguinte mostra como usar min com um array 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 é:

intervalo

range(startIndex, count)

Cria uma matriz de inteiros a partir de um inteiro inicial e contendo vários itens.

Em Bicep, use a função range.

Parâmetros

Valor devolvido

Uma matriz de inteiros.

Exemplo

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

{
  "$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.

Em Bicep, use a função skip.

Parâmetros

Valor devolvido

Uma matriz ou cadeia de caracteres.

Exemplo

O exemplo seguinte omite o número especificado de elementos no array e o número especificado de caracteres numa cadeia:

{
  "$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 ou cadeia de caracteres. Uma matriz tem o número especificado de elementos desde o início da matriz. Uma cadeia de caracteres tem o número especificado de caracteres desde o início da cadeia de caracteres.

Em Bicep, use a função take.

Parâmetros

Valor devolvido

Uma matriz ou cadeia de caracteres.

Exemplo

O exemplo seguinte toma o número especificado de elementos de um array e caracteres de uma cadeia:

{
  "$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 a evitar falhas de implantação ao tentar acessar uma propriedade ou índice inexistente em um objeto ou matriz. Se a chave ou índice especificados não existir, tryGet devolve nulo em vez de gerar um erro.

No Bicep, use o operador safe-dereference .

Parâmetros

Valor devolvido

Devolve o valor na chave ou índice, caso exista. Retorna nulo se a chave ou índice estiver em falta ou fora dos limites.

Exemplo

O exemplo seguinte verifica se um array, objeto e cadeia 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)]"
    }
  }
}

A saída do exemplo anterior é:

tryIndexFromEnd

tryIndexFromEnd(sourceArray, reverseIndex)

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

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

Parâmetros

Valor devolvido

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

Exemplo

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

{
  "$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, valores duplicados são incluídos uma vez. Para objetos, nomes de propriedade duplicados são incluídos apenas uma vez.

Em Bicep, use a função union.

Parâmetros

Valor devolvido

Uma matriz ou objeto.

Observações

O union function utiliza 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 adiciona-o ao resultado se ainda não estiver presente. Em seguida, ele repete o processo para o segundo parâmetro e quaisquer outros parâmetros. Se um valor já estiver presente, seu posicionamento anterior na matriz será preservado.

Para objetos, nomes de propriedade e valores do primeiro parâmetro são adicionados ao resultado. Para parâmetros posteriores, quaisquer 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ó funde os elementos de topo como também funde recursivamente quaisquer objetos aninhados dentro deles. Os valores de 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'))]"
    }
  }
}

A saída do exemplo anterior é:

Se os arrays aninhados fossem fundidos, o valor de objectOutput.nestedArray é [1, 2, 3, 4], e o valor de arrayOutput é [["um", "dois", "três"], ["três", "quatro", "dois"]].

Próximos passos

• Para obter uma descrição das seções em um modelo ARM, consulte Compreender a estrutura e a sintaxe dos modelos ARM.