Funzioni matrice per i modelli di ARM

Articolo
03/25/2024

Questo articolo descrive le funzioni modello operare con le matrici.

Per ottenere una matrice di valori stringa delimitata da un valore, vedere split.

Suggerimento

È consigliabile Bicep perché offre le stesse funzionalità dei modelli di ARM e la sintassi è più semplice da usare. Per ulteriori informazioni, vedere funzioni array (matrice).

array

array(convertToArray)

Converte il valore in matrice.

In Bicep usare la funzione array (matrice).

Parametri

Parametro	Richiesto	Type	Descrizione
convertToArray	Sì	int, stringa, matrice o oggetto	Valore da convertire in matrice.

Valore restituito

Matrice .

Esempio

L'esempio seguente mostra come usare la funzione matrice con tipi diversi.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
intOutput	Matrice	[1]
stringOutput	Matrice	["efgh"]
objectOutput	Matrice	[{"a": "b", "c": "d"}]

concat

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

Combina più matrici e restituisce la matrice concatenata oppure combina più valori di stringa e restituisce la stringa concatenata.

In Bicep usare la funzione concat (concatena).

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	stringa o matrice	La prima matrice o stringa per la concatenazione.
altri argomenti	No	stringa o matrice	Matrici o stringhe aggiuntive in ordine sequenziale per la concatenazione.

Questa funzione può accettare qualsiasi numero di argomenti e può accettare stringhe o matrici per i parametri. Tuttavia, non è possibile fornire matrici e stringhe per i parametri. Le matrici sono concatenate solo con altre matrici.

Valore restituito

Stringa o matrice di valori concatenati.

Esempio

L'esempio seguente illustra come combinare due matrici.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
return	Matrice	["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"]

L'esempio seguente illustra come combinare due valori stringa e restituisce una stringa concatenata.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
concatOutput	String	prefix-5yj4yjf5mbg72

contains

contains(container, itemToFind)

Verifica se una matrice contiene un valore, se un oggetto contiene una chiave o se una stringa contiene una sottostringa. Il confronto fra stringhe fa distinzione tra maiuscole e minuscole. Tuttavia, quando si testa se un oggetto contiene una chiave, il confronto non fa distinzione tra maiuscole e minuscole.

In Bicep usare la funzione contains (contiene).

Parametri

Parametro	Richiesto	Type	Descrizione
container	Sì	matrice, oggetto o stringa	Valore che contiene il valore da trovare.
itemToFind	Sì	stringa o numero intero	Valore da trovare.

Valore restituito

True se l'elemento viene individuato; in caso contrario, restituisce False.

Esempio

L'esempio seguente mostra come usare la funzione contains con tipi diversi:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
stringTrue	Bool	Vero
stringFalse	Bool	Falso
objectTrue	Bool	Vero
objectFalse	Bool	Falso
arrayTrue	Bool	Vero
arrayFalse	Bool	Falso

createArray

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

Crea una matrice dai parametri.

La funzione createArray non è supportata in Bicep. Per costruire una matrice, vedere il tipo di dati della matriceBicep.

Parametri

Parametro	Richiesto	Type	Descrizione
args	No	Stringa, numero intero, matrice o oggetto	I valori nella matrice.

Valore restituito

Matrice . Quando non vengono forniti parametri, restituisce una matrice vuota.

Esempio

L'esempio seguente mostra come usare la funzione createArray con tipi diversi:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
stringArray	Matrice	["a", "b", "c"]
intArray	Matrice	[1, 2, 3]
objectArray	Matrice	[{"one": "a", "two": "b", "three": "c"}]
arrayArray	Matrice	[["one", "two", "three"]]
emptyArray	Matrice	[]

empty

empty(itemToTest)

Determina se una matrice, un oggetto o una stringa sono vuoti.

In Bicep usare la funzione empty (vuota).

Parametri

Parametro	Richiesto	Type	Descrizione
itemToTest	Sì	matrice, oggetto o stringa	Il valore per controllare se è vuota.

Valore restituito

True se il valore è vuoto; in caso contrario, restituisce False.

Esempio

L'esempio seguente controlla se una matrice, un oggetto e una stringa sono vuoti.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayEmpty	Bool	Vero
objectEmpty	Bool	Vero
stringEmpty	Bool	Vero

primo

first(arg1)

Restituisce il primo elemento della matrice o il primo carattere della stringa.

In Bicep usare la funzione first (prima).

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	stringa o matrice	Valore per recuperare il primo elemento o carattere.

Valore restituito

Il tipo (string, int, array o object) del primo elemento di una matrice o il primo carattere di una stringa.

Esempio

L'esempio seguente mostra come usare la prima funzione con una matrice e una stringa.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayOutput	String	Uno
stringOutput	String	O

indexOf

indexOf(arrayToSearch, itemToFind)

Restituisce un numero intero per l'indice della prima occorrenza di un elemento in una matrice. Il confronto è case sensitive (sensibile alle maiuscole) per le stringhe.

Parametri

Parametro	Richiesto	Type	Descrizione
arrayToSearch	Sì	array	La matrice da usare per trovare l'indice dell'elemento cercato.
itemToFind	Sì	int, stringa, matrice o oggetto	L’elemento da trovare nella matrice.

Valore restituito

Un intero che rappresenta il primo indice dell'elemento nella matrice. L’indice è in base zero. Se l'elemento non viene trovato, viene restituito -1.

Esempi

L'esempio seguente mostra come usare le funzioni 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)]"
    }
  }
}

L'output dell'esempio precedente è:

Nome	Type	Valore
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, ...)

Restituisce una matrice o un oggetto singoli con gli elementi comuni dei parametri.

In Bicep usare la funzione intersection (intersezione).

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	matrice o oggetto	Primo valore da usare per cercare elementi comuni.
arg2	Sì	matrice o oggetto	Secondo valore da usare per cercare elementi comuni.
altri argomenti	No	matrice o oggetto	Valori aggiuntivi da usare per cercare elementi comuni.

Valore restituito

Una matrice o un oggetto con elementi comuni.

Esempio

L'esempio seguente mostra come usare l'intersezione con matrici e oggetti:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
objectOutput	Oggetto	{"one": "a", "three": "c"}
arrayOutput	Matrice	["two", "three"]

ultimo

last(arg1)

Restituisce l'ultimo elemento della matrice o l'ultimo carattere della stringa.

In Bicep usare la funzione last (ultima).

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	stringa o matrice	Valore per recuperare l'ultimo elemento o carattere.

Valore restituito

Il tipo (string, int, array o object) dell'ultimo elemento di una matrice o l'ultimo carattere di una stringa.

Esempio

L'esempio seguente mostra come usare l'ultima funzione con una matrice e una stringa.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayOutput	String	tre
stringOutput	String	e

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

Restituisce un intero per l'indice dell'ultima occorrenza di un elemento in una matrice. Il confronto è case sensitive (sensibile alle maiuscole) per le stringhe.

Parametri

Parametro	Richiesto	Type	Descrizione
arrayToSearch	Sì	array	La matrice da usare per trovare l'indice dell'elemento cercato.
itemToFind	Sì	int, stringa, matrice o oggetto	L’elemento da trovare nella matrice.

Valore restituito

Un intero che rappresenta l'ultimo indice dell'elemento nella matrice. L’indice è in base zero. Se l'elemento non viene trovato, viene restituito -1.

Esempi

L'esempio seguente mostra come usare le funzioni 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)]"
    }
  }
}

L'output dell'esempio precedente è:

Nome	Type	Valore
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)

Restituisce il numero di elementi in una matrice, caratteri in una stringa o proprietà a livello radice in un oggetto .

In Bicep usare la funzione length (lunghezza).

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	matrice, stringa o oggetto	La matrice da utilizzare per ottenere il numero di elementi, la stringa da utilizzare per ottenere il numero di caratteri o l'oggetto da utilizzare per ottenere il numero di proprietà a livello radice.

Valore restituito

Numero intero

Esempio

L'esempio seguente mostra come usare la funzione length con una matrice e una stringa:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayLength	Int	3
stringLength	Int	13
objectLength	Int	4

È possibile usare questa funzione con una matrice per specificare il numero di iterazioni durante la creazione di risorse. Nell'esempio seguente, il parametro siteNames fa riferimento a una matrice di nomi da usare durante la creazione di siti Web.

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

Per altre informazioni sull'uso di questa funzione con una matrice, vedere Iterazione delle risorse nei modelli di ARM.

max

max(arg1)

Restituisce il valore massimo da una matrice di numeri interi o da un elenco di numeri interi delimitato da virgole.

In Bicep usare la funzione max .

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	matrice di numeri interi o elenco di numeri interi delimitato da virgole	La raccolta per ottenere il valore massimo.

Valore restituito

Numero intero che rappresenta il valore massimo.

Esempio

L'esempio seguente mostra come usare la funzione max con una matrice e un elenco di numeri interi:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayOutput	Int	5
intOutput	Int	5

min

min(arg1)

Restituisce il valore minimo di una matrice di numeri interi o di un elenco di numeri interi delimitato da virgole.

In Bicep usare la funzione min .

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	matrice di numeri interi o elenco di numeri interi delimitato da virgole	La raccolta per ottenere il valore minimo.

Valore restituito

Numero intero che rappresenta il valore minimo.

Esempio

L'esempio seguente mostra come usare la funzione min con una matrice e un elenco di numeri interi:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayOutput	Int	0
intOutput	Int	0

range

range(startIndex, count)

Crea una matrice di numeri interi da un numero intero iniziale, contenente un dato numero di elementi.

In Bicep usare la funzione range (intervallo).

Parametri

Parametro	Richiesto	Type	Descrizione
startIndex	Sì	int	Primo numero intero nella matrice. La somma di startIndex e count non deve essere maggiore di 2147483647.
numero	Sì	int	Numero di valori interi della matrice. Deve essere un numero intero non negativo fino a 10000.

Valore restituito

Matrice di numeri interi.

Esempio

L'esempio seguente mostra come usare la funzione 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'))]"
    }
  }
}

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
rangeOutput	Matrice	[5, 6, 7]

skip

skip(originalValue, numberToSkip)

Restituisce una matrice con tutti gli elementi dopo il numero specificato nella matrice stessa o una stringa con tutti i caratteri dopo il numero specificato nella stringa stessa.

In Bicep usare la funzione skip (ignora).

Parametri

Parametro	Richiesto	Type	Descrizione
originalValue	Sì	stringa o matrice	Stringa o matrice da usare per i valori da ignorare.
numberToSkip	Sì	int	Numero di elementi o caratteri da ignorare. Se il valore è minore o uguale a 0, vengono restituiti tutti gli elementi o i caratteri nel valore. Se il valore è maggiore della lunghezza della stringa o della matrice, viene restituita una stringa o una matrice vuota.

Valore restituito

Stringa o matrice.

Esempio

L'esempio seguente ignora il numero di elementi specificato nella matrice e il numero di caratteri specificato in una stringa.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayOutput	Matrice	["three"]
stringOutput	String	two three

take

take(originalValue, numberToTake)

Restituisce una matrice o una stringa. Una matrice con il numero specificato di elementi dall'inizio della matrice. Una stringa con il numero specificato di caratteri dall'inizio della stringa.

In Bicep usare la funzione take (prendi).

Parametri

Parametro	Richiesto	Type	Descrizione
originalValue	Sì	stringa o matrice	Stringa o matrice da cui prendere gli elementi.
numberToTake	Sì	int	Numero di elementi o caratteri da prendere. Se il valore è minore o uguale a 0, viene restituita una stringa o un matrice vuota. Se è maggiore della lunghezza della stringa o della matrice specificate, vengono restituiti tutti gli elementi nella stringa o nella matrice.

Valore restituito

Stringa o matrice.

Esempio

L'esempio seguente prende il numero specificato di elementi dalla matrice e di caratteri dalla stringa.

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
arrayOutput	Matrice	["one", "two"]
stringOutput	String	on

union

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

Restituisce una matrice o un oggetto singoli con tutti gli elementi dei parametri. Per le matrici, i valori duplicati vengono inclusi una sola volta. Per gli oggetti, i nomi delle proprietà duplicati vengono inclusi una sola volta.

In Bicep usare la funzione union (unione).

Parametri

Parametro	Richiesto	Type	Descrizione
arg1	Sì	matrice o oggetto	Primo valore da usare per l'aggiunta di elementi.
arg2	Sì	matrice o oggetto	Secondo valore da usare per l'aggiunta di elementi.
altri argomenti	No	matrice o oggetto	Valori aggiuntivi da usare per unire gli elementi.

Valore restituito

Una matrice o un oggetto.

Osservazioni:

La funzione di unione usa la sequenza dei parametri per determinare l'ordine e i valori del risultato.

Per le matrici, la funzione itera attraverso ogni elemento nel primo parametro e lo aggiunge al risultato, se non è già presente. Ripete quindi il processo per il secondo parametro e per gli altri parametri. Se un valore è già presente, la sua posizione precedente nella matrice viene mantenuta.

Per gli oggetti, i nomi delle proprietà e i valori del primo parametro vengono aggiunti al risultato. Per i parametri successivi, tutti i nuovi nomi vengono aggiunti al risultato. Se un parametro successivo ha una proprietà con stesso nome, tale valore sovrascrive il valore esistente. L'ordine delle proprietà non è garantito.

La funzione di unione unisce non solo gli elementi di primo livello, ma unisce in modo ricorsivo anche tutti gli oggetti annidati all'interno di essi. I valori annidati della matrice non vengono uniti. Vedere il secondo esempio nella sezione seguente.

Esempio

L'esempio seguente mostra come usare l'unione con matrici e oggetti:

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

L'output dell'esempio precedente con i valori predefiniti è il seguente:

Nome	Type	Valore
objectOutput	Oggetto	{"one": "a", "two": "b", "three": "c2", "four": "d", "five": "e"}
arrayOutput	Matrice	["one", "two", "three", "four"]

L'esempio seguente mostra la funzionalità deep merge:

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

L'output dell'esempio precedente è:

Nome	Type	Valore
objectOutput	Oggetto	{"property":{"one":"a","two":"b","three":"c2","four":"d","five":"e"},"nestedArray":[3,4]}
arrayOutput	Matrice	[["one","two"],["three"],["four","two"]]

Se le matrici annidate sono state unite, il valore di objectOutput.nestedArray sarà [1, 2, 3, 4], e il valore di arrayOutput sarà [["one", "two", "three"], ["three", "four", "two"]].

Passaggi successivi

Per una descrizione delle sezioni in un modello di ARM, vedere Comprendere la struttura e la sintassi dei modelli di ARM.

Condividi tramite

Funzioni matrice per i modelli di ARM

array

Parametri

Valore restituito

Esempio

concat

Parametri

Valore restituito

Esempio

contains

Parametri

Valore restituito

Esempio

createArray

Parametri

Valore restituito

Esempio

empty

Parametri

Valore restituito

Esempio

primo

Parametri

Valore restituito

Esempio

indexOf

Parametri

Valore restituito

Esempi

intersection

Parametri

Valore restituito

Esempio

ultimo

Parametri

Valore restituito

Esempio

lastIndexOf

Parametri

Valore restituito

Esempi

length

Parametri

Valore restituito

Esempio

max

Parametri

Valore restituito

Esempio

min

Parametri

Valore restituito

Esempio

range

Parametri

Valore restituito

Esempio

skip

Parametri

Valore restituito

Esempio

take

Parametri

Valore restituito

Esempio

union

Parametri

Valore restituito

Osservazioni:

Esempio

Passaggi successivi

Commenti e suggerimenti

Risorse aggiuntive