Funkcje tablicy dla szablonów usługi ARM

W tym artykule opisano funkcje szablonu do pracy z tablicami.

Aby uzyskać tablicę wartości ciągów rozdzielonych przez wartość, zobacz podział.

macierz

array(convertToArray)

Konwertuje wartość na tablicę.

W Bicep użyj array funkcji .

Parametry

Wartość zwracana

Tablicy.

Przykład

W poniższym przykładzie pokazano, jak używać array funkcji z różnymi typami:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

concat

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

Łączy wiele tablic i zwraca połączoną tablicę lub łączy wiele wartości ciągów i zwraca połączony ciąg.

W Bicep użyj concat funkcji .

Parametry

Ta funkcja może przyjmować dowolną liczbę argumentów i może akceptować ciągi lub tablice dla parametrów. Nie można jednak podać zarówno tablic, jak i ciągów dla parametrów. Tablice są łączone tylko z innymi tablicami.

Wartość zwracana

Ciąg lub tablica połączonych wartości.

Przykład

W poniższym przykładzie pokazano, jak połączyć dwie tablice:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

W poniższym przykładzie pokazano, jak połączyć dwie wartości ciągu i zwrócić połączony ciąg:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

zawiera

contains(container, itemToFind)

Sprawdza, czy tablica zawiera wartość, obiekt zawiera klucz lub ciąg zawiera podciąg. Porównanie ciągów uwzględnia wielkość liter. Jednak podczas testowania, czy obiekt zawiera klucz, porównanie jest bez uwzględniania wielkości liter.

W Bicep użyj contains funkcji .

Parametry

Wartość zwracana

Wartość True , jeśli element zostanie znaleziony; w przeciwnym razie wartość False.

Przykład

W poniższym przykładzie pokazano, jak używać z contains różnymi typami:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

createArray (tablica tworzenie)

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

Tworzy tablicę na podstawie parametrów.

W Bicep createArray funkcja nie jest obsługiwana. Aby utworzyć tablicę, zobacz typ danych tablicy Bicep.

Parametry

Wartość zwracana

Tablicy. Jeśli nie podano żadnych parametrów, zwraca pustą tablicę.

Przykład

W poniższym przykładzie pokazano, jak używać z createArray różnymi typami:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

pusty

empty(itemToTest)

Określa, czy tablica, obiekt lub ciąg jest pusta.

W Bicep użyj empty funkcji .

Parametry

Wartość zwracana

Zwraca wartość True , jeśli wartość jest pusta; w przeciwnym razie wartość False.

Przykład

Poniższy przykład sprawdza, czy tablica, obiekt i ciąg są puste:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

pierwszy

first(arg1)

Zwraca pierwszy element tablicy lub pierwszy znak ciągu.

W Bicep użyj first funkcji .

Parametry

Wartość zwracana

Typ (ciąg, int, tablica lub obiekt) pierwszego elementu w tablicy lub pierwszy znak ciągu.

Przykład

W poniższym przykładzie pokazano, jak używać first funkcji z tablicą i ciągiem:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

indexFromEnd

indexFromEnd(sourceArray, reverseIndex)

Zwraca element tablicy, licząc wstecz od końca. Jest to przydatne, gdy chcesz odwoływać się do elementów rozpoczynających się od końca listy, a nie od początku. Funkcja tryIndexFromEnd jest bezpieczną wersją .indexFromEnd

W Bicep użyj operatora dostępu indeksu zarezerwowanego .

Parametry

Wartość zwracana

Pojedynczy element z tablicy wybrany przez zliczanie do tyłu od końca tablicy.

Przykład

W poniższym przykładzie pokazano, jak używać indexFromEnd funkcji:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

indexOf (indeks)

indexOf(arrayToSearch, itemToFind)

Zwraca liczbę całkowitą dla indeksu pierwszego wystąpienia elementu w tablicy. Porównanie uwzględnia wielkość liter dla ciągów.

Parametry

Wartość zwracana

Liczba całkowita reprezentująca pierwszy indeks elementu w tablicy. Jest to indeks zaczynający się od zera. Jeśli element nie zostanie znaleziony, zostanie zwrócony -1.

Przykłady

W poniższym przykładzie pokazano, jak używać indexOf funkcji i 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)]"
    }
  }
}

Dane wyjściowe z poprzedniego przykładu to:

skrzyżowanie

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

Zwraca pojedynczą tablicę lub obiekt ze wspólnymi elementami z parametrów.

W Bicep użyj intersection funkcji .

Parametry

Wartość zwracana

Tablica lub obiekt ze wspólnymi elementami.

Przykład

W poniższym przykładzie pokazano, jak używać z intersection tablicami i obiektami:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

ostatni

last(arg1)

Zwraca ostatni element tablicy lub ostatni znak ciągu.

W Bicep użyj last funkcji .

Parametry

Wartość zwracana

Typ (ciąg, int, tablica lub obiekt) ostatniego elementu w tablicy lub ostatni znak ciągu.

Przykład

W poniższym przykładzie pokazano, jak używać last funkcji z tablicą i ciągiem:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

lastIndexOf (ostatni indeks)

lastIndexOf(arrayToSearch, itemToFind)

Zwraca liczbę całkowitą dla indeksu ostatniego wystąpienia elementu w tablicy. Porównanie uwzględnia wielkość liter dla ciągów.

Parametry

Wartość zwracana

Liczba całkowita reprezentująca ostatni indeks elementu w tablicy. Jest to indeks zaczynający się od zera. Jeśli element nie zostanie znaleziony, zostanie zwrócony -1.

Przykłady

W poniższym przykładzie pokazano, jak używać indexOf funkcji i 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)]"
    }
  }
}

Dane wyjściowe z poprzedniego przykładu to:

długość

length(arg1)

Zwraca liczbę elementów w tablicy, znaki w ciągu lub właściwości na poziomie głównym w obiekcie.

W Bicep użyj length funkcji .

Parametry

Wartość zwracana

Int.

Przykład

W poniższym przykładzie pokazano, jak używać z length tablicą i ciągiem:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

Tej funkcji można użyć z tablicą, aby określić liczbę iteracji podczas tworzenia zasobów. W poniższym przykładzie parametr siteNames odnosi się do tablicy nazw do użycia podczas tworzenia witryn internetowych:

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

Aby uzyskać więcej informacji na temat używania tej funkcji z tablicą, zobacz Iteracja zasobów w szablonach usługi ARM.

maks

max(arg1)

Zwraca wartość maksymalną z tablicy liczb całkowitych lub rozdzielanej przecinkami listy liczb całkowitych.

W Bicep użyj max funkcji .

Parametry

Wartość zwracana

Liczba całkowita reprezentująca wartość maksymalną.

Przykład

W poniższym przykładzie pokazano, jak używać z max tablicą i listą liczb całkowitych:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

Min

min(arg1)

Zwraca minimalną wartość z tablicy liczb całkowitych lub rozdzielanej przecinkami listy liczb całkowitych.

W Bicep użyj min funkcji .

Parametry

Wartość zwracana

Liczba int reprezentująca minimalną wartość.

Przykład

W poniższym przykładzie pokazano, jak używać z min tablicą i listą liczb całkowitych:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

zakres

range(startIndex, count)

Tworzy tablicę liczb całkowitych na podstawie początkowej liczby całkowitej i zawiera liczbę elementów.

W Bicep użyj range funkcji .

Parametry

Wartość zwracana

Tablica liczb całkowitych.

Przykład

W poniższym przykładzie pokazano, jak używać range funkcji:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

pominąć

skip(originalValue, numberToSkip)

Zwraca tablicę ze wszystkimi elementami po określonej liczbie w tablicy lub zwraca ciąg ze wszystkimi znakami po określonej liczbie w ciągu.

W Bicep użyj skip funkcji .

Parametry

Wartość zwracana

Tablica lub ciąg.

Przykład

Poniższy przykład pomija określoną liczbę elementów w tablicy i określoną liczbę znaków w ciągu:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

brać

take(originalValue, numberToTake)

Zwraca tablicę lub ciąg. Tablica ma określoną liczbę elementów od początku tablicy. Ciąg ma określoną liczbę znaków od początku ciągu.

W Bicep użyj take funkcji .

Parametry

Wartość zwracana

Tablica lub ciąg.

Przykład

W poniższym przykładzie określona liczba elementów z tablicy i znaków z ciągu:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

tryGet

tryGet(itemToTest, keyOrIndex)

tryGet Pomaga uniknąć niepowodzeń wdrażania podczas próby uzyskania dostępu do nieistniejącej właściwości lub indeksu w obiekcie lub tablicy. Jeśli określony klucz lub indeks nie istnieje, tryGet zwraca wartość null zamiast zgłaszać błąd.

W Bicep użyj operatora safe-dereference .

Parametry

Wartość zwracana

Zwraca wartość w kluczu/indeksie, jeśli istnieje. Zwraca wartość null, jeśli brakuje klucza/indeksu lub poza granicami.

Przykład

Poniższy przykład sprawdza, czy tablica, obiekt i ciąg są puste:

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

Dane wyjściowe z poprzedniego przykładu to:

tryIndexFromEnd

tryndexFromEnd(sourceArray, reverseIndex)

Funkcja tryIndexFromEnd jest bezpieczną wersją .indexFromEnd Pobiera wartość z tablicy, licząc wstecz od końca bez zgłaszania błędu, jeśli indeks jest poza zakresem.

W elemencie Bicep użyj operatora dostępu indeksu zarezerwowanego i operatora Safe dereference .

Parametry

Wartość zwracana

Jeśli indeks jest prawidłowy (w granicach tablicy), zwraca element tablicy w tym indeksie odwrotnym. Jeśli indeks jest poza zakresem, zwraca wartość null zamiast zgłaszać błąd.

Przykład

W poniższym przykładzie pokazano, jak używać tryIndexFromEnd funkcji:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

W poniższym przykładzie pokazano scenariusz poza granicą:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

związek

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

Zwraca pojedynczą tablicę lub obiekt ze wszystkimi elementami z parametrów. W przypadku tablic są uwzględniane zduplikowane wartości raz. W przypadku obiektów zduplikowane nazwy właściwości są uwzględniane tylko raz.

W Bicep użyj union funkcji .

Parametry

Wartość zwracana

Tablica lub obiekt.

Uwagi

Funkcja union function używa sekwencji parametrów, aby określić kolejność i wartości wyniku.

W przypadku tablic funkcja iteruje każdy element w pierwszym parametrze i dodaje go do wyniku, jeśli nie jest jeszcze obecny. Następnie powtarza proces dla drugiego parametru i kolejnych parametrów. Jeśli wartość jest już obecna, jej wcześniejsze umieszczenie w tablicy jest zachowywane.

W przypadku obiektów nazwy właściwości i wartości z pierwszego parametru są dodawane do wyniku. W przypadku późniejszych parametrów wszystkie nowe nazwy są dodawane do wyniku. Jeśli późniejszy parametr ma właściwość o tej samej nazwie, ta wartość zastępuje istniejącą wartość. Kolejność właściwości nie jest gwarantowana.

Funkcja union nie tylko scala elementy najwyższego poziomu, ale także rekursywnie scala wszystkie zagnieżdżone obiekty w nich. Zagnieżdżone wartości tablicy nie są scalane. Zobacz drugi przykład w poniższej sekcji.

Przykład

W poniższym przykładzie pokazano, jak używać z union tablicami i obiektami:

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

Dane wyjściowe wartości domyślnych z poprzedniego przykładu to:

W poniższym przykładzie przedstawiono możliwość głębokiego scalania:

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

Dane wyjściowe z poprzedniego przykładu to:

Jeśli zagnieżdżone tablice zostały scalone, wartość objectOutput.nestedArray to [1, 2, 3, 4], a wartość arrayOutput to [["one", "two", "three"], ["three", "four", "two"]].

Następne kroki

• Aby zapoznać się z opisem sekcji w szablonie usługi ARM, zobacz Omówienie struktury i składni szablonów usługi ARM.