Funciones de matriz para plantillas de Resource Manager

En este artículo se describen las funciones de la plantilla para trabajar con matrices.

Para obtener una matriz de valores de cadena delimitada por un valor, consulte split.

array

array(convertToArray)

Convierte el valor en una matriz.

En Bicep, use la array función .

Parámetros

Valor devuelto

Matriz .

Ejemplo

En el ejemplo siguiente se muestra cómo usar la array función con distintos 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'))]"
    }
  }
}

La salida de los valores predeterminados del ejemplo anterior es:

concat

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

Combina varias matrices y devuelve la matriz concatenada, o combina varios valores de cadena y devuelve la cadena concatenada.

En Bicep, use la concat función .

Parámetros

Esta función puede tomar cualquier número de argumentos y puede aceptar cadenas o matrices para los parámetros. Sin embargo, no puede proporcionar ambas a la vez para los parámetros. Las matrices solo se concatenan con otras matrices.

Valor devuelto

Una cadena o matriz de valores concatenados.

Ejemplo

En el ejemplo siguiente se muestra cómo combinar dos matrices:

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

La salida de los valores predeterminados del ejemplo anterior es:

En el ejemplo siguiente se muestra cómo combinar dos valores de cadena y devolver una cadena 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))]"
    }
  }
}

La salida de los valores predeterminados del ejemplo anterior es:

contiene

contains(container, itemToFind)

Comprueba si una matriz contiene un valor, un objeto contiene una clave o una cadena que contiene una subcadena. La comparación de cadena distingue mayúsculas de minúsculas. Pero, cuando se prueba si un objeto contiene una clave, la comparación no distingue mayúsculas de minúsculas.

En Bicep, use la contains función .

Parámetros

Valor devuelto

True si el elemento se encuentra; en caso contrario, False.

Ejemplo

En el ejemplo siguiente se muestra cómo utilizar contains con 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')]"
    }
  }
}

La salida de los valores predeterminados del ejemplo anterior es:

createArray

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

Crea una matriz a partir de los parámetros.

En Bicep, la función createArray no se admite. Para construir una matriz, consulte el tipo de datos de la matriz de Bicep.

Parámetros

Valor devuelto

Matriz . Cuando no se proporciona ningún parámetro, devuelve una matriz vacía.

Ejemplo

En el ejemplo siguiente se muestra cómo utilizar createArray con 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()]"
    }
  }
}

La salida de los valores predeterminados del ejemplo anterior es:

vacío

empty(itemToTest)

Determina si una matriz, un objeto o una cadena están vacíos.

En Bicep, use la empty función .

Parámetros

Valor devuelto

Devuelve True si el valor está vacío; en caso contrario, False.

Ejemplo

En el ejemplo siguiente se comprueba si una matriz, un objeto y una cadena están vacíos:

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

La salida de los valores predeterminados del ejemplo anterior es:

primero

first(arg1)

Devuelve el primer elemento de la matriz o el primer carácter de la cadena.

En Bicep, use la first función .

Parámetros

Valor devuelto

El tipo (cadena, entero, matriz u objeto) del primer elemento en una matriz o el primer carácter de una cadena.

Ejemplo

En el ejemplo siguiente se muestra cómo usar la first función con una matriz y una cadena:

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

La salida de los valores predeterminados del ejemplo anterior es:

indexFromEnd

indexFromEnd(sourceArray, reverseIndex)

Devuelve un elemento de la matriz contando hacia atrás desde el final. Esto resulta útil cuando se desea hacer referencia a elementos a partir del final de una lista en lugar del principio. La tryIndexFromEnd función es una versión segura de indexFromEnd.

En Bicep, use el operador de descriptor de acceso de índice reservado .

Parámetros

Valor devuelto

Un único elemento de una matriz, seleccionado contando hacia atrás desde el final de la matriz.

Ejemplo

En el ejemplo siguiente se muestra cómo usar la indexFromEnd función :

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

La salida de los valores predeterminados del ejemplo anterior es:

indexOf

indexOf(arrayToSearch, itemToFind)

Devuelve un entero para el índice de la primera aparición de un elemento en una matriz. La comparación distingue mayúsculas de minúsculas para las cadenas.

Parámetros

Valor devuelto

Entero que representa el primer índice del elemento en la matriz. El índice es de base cero. Si no se encuentra el elemento, se devuelve -1.

Ejemplos

En el ejemplo siguiente se muestra cómo usar las funciones indexOf y 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)]"
    }
  }
}

El resultado del ejemplo anterior es:

intersección

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

Devuelve una única matriz u objeto con los elementos comunes de los parámetros.

En Bicep, use la intersection función .

Parámetros

Valor devuelto

Una matriz o un objeto con los elementos comunes.

Ejemplo

En el ejemplo siguiente se muestra cómo utilizar intersection con matrices y 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'))]"
    }
  }
}

La salida de los valores predeterminados del ejemplo anterior es:

último

last(arg1)

Devuelve el último elemento de la matriz o el último carácter de la cadena.

En Bicep, use la last función .

Parámetros

Valor devuelto

El tipo (cadena, entero, matriz u objeto) del último elemento de una matriz o el último carácter de una cadena.

Ejemplo

En el ejemplo siguiente se muestra cómo usar la last función con una matriz y una cadena:

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

La salida de los valores predeterminados del ejemplo anterior es:

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

Devuelve un entero para el índice de la última aparición de un elemento en una matriz. La comparación distingue mayúsculas de minúsculas para las cadenas.

Parámetros

Valor devuelto

Entero que representa el último índice del elemento en la matriz. El índice es de base cero. Si no se encuentra el elemento, se devuelve -1.

Ejemplos

En el ejemplo siguiente se muestra cómo usar las funciones indexOf y 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)]"
    }
  }
}

El resultado del ejemplo anterior es:

largura

length(arg1)

Devuelve el número de elementos de una matriz, caracteres de una cadena o propiedades de nivel raíz de un objeto.

En Bicep, use la length función .

Parámetros

Valor devuelto

Un entero.

Ejemplo

En el ejemplo siguiente se muestra cómo usar length con una matriz y una cadena:

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

La salida de los valores predeterminados del ejemplo anterior es:

Puede usar esta función con una matriz para especificar el número de iteraciones al crear recursos. En el ejemplo siguiente, el parámetro siteNames hace referencia a una matriz de nombres que se usarán al crear sitios web:

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

Para más información sobre el uso de esta función con una matriz, consulte Iteración de recursos en las plantillas de Resource Manager.

máximo

max(arg1)

Devuelve el valor máximo de una matriz de enteros o una lista separada por comas de enteros.

En Bicep, use la max función .

Parámetros

Valor devuelto

Un entero que representa el valor máximo.

Ejemplo

En el ejemplo siguiente se muestra cómo usar max con una matriz y una lista de enteros:

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

La salida de los valores predeterminados del ejemplo anterior es:

Min

min(arg1)

Devuelve el valor mínimo de una matriz de enteros o una lista separada por comas de enteros.

En Bicep, use la min función .

Parámetros

Valor devuelto

Un entero que representa el valor mínimo.

Ejemplo

En el ejemplo siguiente se muestra cómo usar min con una matriz y una lista de enteros:

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

La salida de los valores predeterminados del ejemplo anterior es:

range

range(startIndex, count)

Crea una matriz de enteros a partir de un entero de inicio y contiene un número de elementos.

En Bicep, use la range función .

Parámetros

Valor devuelto

Una matriz de enteros.

Ejemplo

En el ejemplo siguiente se muestra cómo usar la range función :

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

La salida de los valores predeterminados del ejemplo anterior es:

skip

skip(originalValue, numberToSkip)

Devuelve una matriz con todos los elementos después del número especificado de la matriz, o devuelve una cadena con todos los caracteres después del número especificado en la cadena.

En Bicep, use la skip función .

Parámetros

Valor devuelto

Una matriz o cadena.

Ejemplo

En el ejemplo siguiente se omite el número especificado de elementos de la matriz y el número especificado de caracteres de una cadena:

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

La salida de los valores predeterminados del ejemplo anterior es:

tomar

take(originalValue, numberToTake)

Devuelve una matriz o una cadena. Una matriz tiene el número especificado de elementos desde el principio de la matriz. Una cadena tiene el número especificado de caracteres desde el principio de la cadena.

En Bicep, use la take función .

Parámetros

Valor devuelto

Una matriz o cadena.

Ejemplo

En el ejemplo siguiente se toma el número especificado de elementos de una matriz y caracteres de una cadena:

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

La salida de los valores predeterminados del ejemplo anterior es:

tryGet

tryGet(itemToTest, keyOrIndex)

tryGet ayuda a evitar errores de implementación al intentar acceder a una propiedad o índice inexistentes en un objeto o matriz. Si la clave o el índice especificados no existen, tryGet devuelve null en lugar de producir un error.

En Bicep, use el operador safe-dereference .

Parámetros

Valor devuelto

Devuelve el valor en la clave o índice si existe. Devuelve null si falta la clave o el índice o está fuera de los límites.

Ejemplo

En el ejemplo siguiente se comprueba si una matriz, un objeto y una cadena están vacíos:

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

El resultado del ejemplo anterior es:

tryIndexFromEnd

tryndexFromEnd(sourceArray, reverseIndex)

La tryIndexFromEnd función es una versión segura de indexFromEnd. Recupera un valor de una matriz contando hacia atrás desde el final sin producir un error si el índice está fuera del intervalo.

En Bicep, use el operador de descriptor de acceso de índice reservado y el operador de desreferencia segura .

Parámetros

Valor devuelto

Si el índice es válido (dentro de los límites de matriz), devuelve el elemento de matriz en ese índice inverso. Si el índice está fuera del intervalo, devuelve null en lugar de producir un error.

Ejemplo

En el ejemplo siguiente se muestra cómo usar la tryIndexFromEnd función :

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

La salida de los valores predeterminados del ejemplo anterior es:

En el ejemplo siguiente se muestra un escenario no enlazado:

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

La salida de los valores predeterminados del ejemplo anterior es:

union

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

Devuelve una única matriz u objeto con todos los elementos de los parámetros. Para las matrices, los valores duplicados se incluyen una vez. Para los objetos, los nombres de propiedad duplicados solo se incluyen una vez.

En Bicep, use la union función .

Parámetros

Valor devuelto

Una matriz u objeto.

Comentarios

union function utiliza la secuencia de los parámetros para determinar el orden y los valores del resultado.

Para las matrices, la función se itera por cada elemento del primer parámetro y lo agrega al resultado si no está presente. A continuación, repite el proceso para el segundo parámetro y los parámetros adicionales. Si un valor ya existe, se conserva su ubicación anterior en la matriz.

En el caso de los objetos, los nombres de propiedad y los valores del primer parámetro se agregan al resultado. Para los parámetros posteriores, se agregarán los nuevos nombres al resultado. Si un parámetro posterior tiene una propiedad con el mismo nombre, ese valor sobrescribe el valor existente. El orden de las propiedades no está garantizado.

La union función no solo combina los elementos de nivel superior, sino que también combina recursivamente los objetos anidados dentro de ellos. Los valores de matriz anidados no se combinan. Consulte el segundo ejemplo de la sección siguiente.

Ejemplo

En el ejemplo siguiente se muestra cómo utilizar union con matrices y 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'))]"
    }
  }
}

La salida de los valores predeterminados del ejemplo anterior es:

En el ejemplo siguiente se muestra la capacidad de combinación 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'))]"
    }
  }
}

El resultado del ejemplo anterior es:

Si se combinaron matrices anidadas, el valor de objectOutput.nestedArray es [1, 2, 3, 4] y el valor de arrayOutput es [["one", "two", "three"], ["tres", "cuatro", "two"]].

Pasos siguientes

• Para obtener una descripción de las secciones de una plantilla de ARM, vea Nociones sobre la estructura y la sintaxis de las plantillas de Azure Resource Manager.