Funzioni di matrice per i modelli di Resource Manager

Questo articolo descrive le funzioni del modello per l'uso di matrici.

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

Suggerimento

È consigliabile Usare Bicep perché offre le stesse funzionalità dei modelli di Resource Manager e la sintassi è più semplice da usare. Per altre informazioni, vedere Funzioni di matrice .

array

array(convertToArray)

Converte il valore in matrice.

In Bicep usare la funzione matrice .

Parametri

Parametro Obbligatorio Tipo Descrizione
convertToArray 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 Array  [1]
stringOutput Array ["efgh"]
objectOutput Array [{"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 .

Parametri

Parametro Obbligatorio Tipo Descrizione
arg1 stringa o matrice La prima matrice o stringa per la concatenazione.
altri argomenti No stringa o matrice Più matrici o stringhe 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 sia matrici che 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 Array ["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 contiene .

Parametri

Parametro Obbligatorio Tipo Descrizione
contenitore matrice, oggetto o stringa Valore che contiene il valore da trovare.
itemToFind 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 True
stringFalse Bool Falso
objectTrue Bool True
objectFalse Bool Falso
arrayTrue Bool True
arrayFalse Bool Falso

createArray

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

Crea una matrice dai parametri.

In Bicep la createArray funzione non è supportata. Per costruire una matrice, vedere il tipo di dati della matrice Bicep.

Parametri

Parametro Obbligatorio Tipo Descrizione
args No Stringa, numero intero, matrice o oggetto 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 Array ["a", "b", "c"]
intArray Array [1, 2, 3]
objectArray Array [{"one": "a", "two": "b", "three": "c"}]
arrayArray Array [["one", "two", "three"]]
emptyArray Array []

empty

empty(itemToTest)

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

In Bicep usare la funzione vuota .

Parametri

Parametro Obbligatorio Tipo Descrizione
itemToTest matrice, oggetto o stringa Valore da controllare se è vuoto.

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 True
objectEmpty Bool True
stringEmpty Bool True

first

first(arg1)

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

In Bicep usare la prima funzione.

Parametri

Parametro Obbligatorio Tipo Descrizione
arg1 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 one
stringOutput string O

indexOf

indexOf(arrayToSearch, itemToFind)

Restituisce un intero per l'indice della prima occorrenza di un elemento in una matrice. Il confronto è distinzione tra maiuscole e minuscole per le stringhe.

Parametri

Parametro Obbligatorio Tipo Descrizione
arrayToSearch array Matrice da usare per trovare l'indice dell'elemento ricercato.
itemToFind int, stringa, matrice o oggetto Elemento da trovare nella matrice.

Valore restituito

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

Esempio

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

intersezione

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

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

In Bicep usare la funzione di intersezione .

Parametri

Parametro Obbligatorio Tipo Descrizione
arg1 matrice o oggetto Primo valore da usare per cercare elementi comuni.
arg2 matrice o oggetto Secondo valore da usare per cercare elementi comuni.
altri argomenti No matrice o oggetto Altri valori da usare per trovare elementi comuni.

Valore restituito

Una matrice o un oggetto con elementi comuni.

Esempio

Nell'esempio seguente viene illustrato 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 Array ["two", "three"]

last

last(arg1)

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

In Bicep usare l'ultima funzione.

Parametri

Parametro Obbligatorio Tipo Descrizione
arg1 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 three
stringOutput string e

lastIndexOf

lastIndexOf(arrayToSearch, itemToFind)

Restituisce un numero intero per l'indice dell'ultima occorrenza di un elemento in una matrice. Il confronto fa distinzione tra maiuscole e minuscole per le stringhe.

Parametri

Parametro Obbligatorio Tipo Descrizione
arrayToSearch array Matrice da utilizzare per trovare l'indice dell'elemento cercato.
itemToFind int, stringa, matrice o oggetto Elemento da trovare nella matrice.

Valore restituito

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

Esempio

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 .

Parametri

Parametro Obbligatorio Tipo Descrizione
arg1 matrice, stringa o oggetto Matrice da usare per ottenere il numero di elementi, la stringa da usare per ottenere il numero di caratteri o l'oggetto da usare per ottenere il numero di proprietà a livello radice.

Valore restituito

Numero intero

Esempio

Nell'esempio seguente viene illustrato come usare la lunghezza 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 Resource Manager.

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 Obbligatorio Tipo Descrizione
arg1 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

Nell'esempio seguente viene illustrato come usare 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 Obbligatorio Tipo Descrizione
arg1 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

Nell'esempio seguente viene illustrato come usare 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 .

Parametri

Parametro Obbligatorio Tipo Descrizione
startIndex INT Primo numero intero nella matrice. La somma di startIndex e count non deve essere maggiore di 2147483647.
count INT Numero di valori interi della matrice. Deve essere un numero intero non negativo fino a 10000.

Valore restituito

Matrice di numeri interi.

Esempio

Nell'esempio seguente viene illustrato 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 Array [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 .

Parametri

Parametro Obbligatorio Tipo Descrizione
originalValue stringa o matrice Stringa o matrice da usare per i valori da ignorare.
numberToSkip 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 è maggiore della lunghezza della matrice o della stringa, viene restituita una matrice o una stringa 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 Array ["three"]
stringOutput string two three

take

take(originalValue, numberToTake)

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

In Bicep usare la funzione take .

Parametri

Parametro Obbligatorio Tipo Descrizione
originalValue stringa o matrice Stringa o matrice da cui prendere gli elementi.
numberToTake 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 matrice o della stringa specificata, vengono restituiti tutti gli elementi della matrice o della stringa.

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 Array ["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 di unione .

Parametri

Parametro Obbligatorio Tipo Descrizione
arg1 matrice o oggetto Primo valore da usare per l'aggiunta di elementi.
arg2 matrice o oggetto Secondo valore da usare per l'aggiunta di elementi.
altri argomenti No matrice o oggetto Altri valori da usare per l'aggiunta di elementi.

Valore restituito

Una matrice o un oggetto.

Commenti

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

Per le matrici, la funzione esegue l'iterazione di ogni elemento nel primo parametro e lo aggiunge al risultato se non è già presente. Ripete quindi il processo per il secondo parametro e altri parametri. Se un valore è già presente, la 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 lo stesso nome, tale valore sovrascrive il valore esistente. L'ordine delle proprietà non è garantito.

Esempio

Nell'esempio seguente viene illustrato 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 Array ["one", "two", "three", "four"]

Passaggi successivi