Řetězcové funkce pro šablony ARM
Resource Manager poskytuje následující funkce pro práci s řetězci v šabloně Azure Resource Manageru (šablona ARM):
- base64
- base64ToJson
- base64ToString
- concat
- obsahuje
- identifikátor dataURI
- dataUriToString
- empty
- endsWith
- první
- format
- identifikátor guid
- indexOf
- join
- json
- poslední
- lastIndexOf
- length
- newGuid
- padLeft
- replace
- přeskočit
- split
- startsWith
- string
- podřetězec
- vzít
- toLower
- toUpper
- zastřihnout
- uniqueString
- identifikátor uri
- uriComponent
- uriComponentToString
Tip
Doporučujeme Bicep, protože nabízí stejné možnosti jako šablony ARM a syntaxe se snadněji používá. Další informace najdete v tématu Řetězcové funkce.
base64(inputString)
Vrátí reprezentaci vstupního řetězce base64.
V Bicep použijte funkci base64 .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
inputString | Ano | string | Hodnota, která se má vrátit jako reprezentace base64. |
Řetězec obsahující reprezentaci base64.
Následující příklad ukazuje, jak používat base64
funkci.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"stringData": {
"type": "string",
"defaultValue": "one, two, three"
},
"jsonFormattedData": {
"type": "string",
"defaultValue": "{'one': 'a', 'two': 'b'}"
}
},
"variables": {
"base64String": "[base64(parameters('stringData'))]",
"base64Object": "[base64(parameters('jsonFormattedData'))]"
},
"resources": [
],
"outputs": {
"base64Output": {
"type": "string",
"value": "[variables('base64String')]"
},
"toStringOutput": {
"type": "string",
"value": "[base64ToString(variables('base64String'))]"
},
"toJsonOutput": {
"type": "object",
"value": "[base64ToJson(variables('base64Object'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
base64Output | String | b25lLCB0d28sIHRocmVl |
toStringOutput | String | Jedna dva tři |
toJsonOutput | Objekt | {"one": "a", "two": "b"} |
base64ToJson(base64Value)
Převede reprezentaci base64 na objekt JSON.
V bicep použijte funkci base64ToJson .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
base64Value | Ano | string | Reprezentace base64 pro převod na objekt JSON. |
Objekt JSON.
Následující příklad používá base64ToJson
funkci k převodu hodnoty base64:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"stringData": {
"type": "string",
"defaultValue": "one, two, three"
},
"jsonFormattedData": {
"type": "string",
"defaultValue": "{'one': 'a', 'two': 'b'}"
}
},
"variables": {
"base64String": "[base64(parameters('stringData'))]",
"base64Object": "[base64(parameters('jsonFormattedData'))]"
},
"resources": [
],
"outputs": {
"base64Output": {
"type": "string",
"value": "[variables('base64String')]"
},
"toStringOutput": {
"type": "string",
"value": "[base64ToString(variables('base64String'))]"
},
"toJsonOutput": {
"type": "object",
"value": "[base64ToJson(variables('base64Object'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
base64Output | String | b25lLCB0d28sIHRocmVl |
toStringOutput | String | Jedna dva tři |
toJsonOutput | Objekt | {"one": "a", "two": "b"} |
base64ToString(base64Value)
Převede reprezentaci base64 na řetězec.
V bicep použijte funkci base64ToString .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
base64Value | Ano | string | Reprezentace base64, která se má převést na řetězec. |
Řetězec převedené hodnoty base64.
Následující příklad používá base64ToString
funkci k převodu hodnoty base64:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"stringData": {
"type": "string",
"defaultValue": "one, two, three"
},
"jsonFormattedData": {
"type": "string",
"defaultValue": "{'one': 'a', 'two': 'b'}"
}
},
"variables": {
"base64String": "[base64(parameters('stringData'))]",
"base64Object": "[base64(parameters('jsonFormattedData'))]"
},
"resources": [
],
"outputs": {
"base64Output": {
"type": "string",
"value": "[variables('base64String')]"
},
"toStringOutput": {
"type": "string",
"value": "[base64ToString(variables('base64String'))]"
},
"toJsonOutput": {
"type": "object",
"value": "[base64ToJson(variables('base64Object'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
base64Output | String | b25lLCB0d28sIHRocmVl |
toStringOutput | String | Jedna dva tři |
toJsonOutput | Objekt | {"one": "a", "two": "b"} |
concat(arg1, arg2, arg3, ...)
Kombinuje více řetězcových hodnot a vrací zřetězený řetězec nebo kombinuje více polí a vrací zřetězené pole.
V Bicep použijte místo funkce interpolaci concat()
řetězců ke zlepšení čitelnosti. V některých případech, například nahrazení řetězce ve víceřádkových řetězcích, ale možná budete muset vrátit zpět použití concat()
funkce nebo replace()
funkce.
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | řetězec nebo pole | První řetězec nebo pole pro zřetězení |
další argumenty | No | řetězec nebo pole | Více řetězců nebo polí v sekvenčním pořadí pro zřetězení |
Tato funkce může přijmout libovolný počet argumentů a pro parametry může přijímat řetězce nebo pole. Pro parametry ale nemůžete zadat pole i řetězce. Řetězce jsou zřetězeny pouze s jinými řetězci.
Řetězec nebo pole zřetězených hodnot.
Následující příklad ukazuje, jak zkombinovat dvě řetězcové hodnoty a vrátit zřetězený řetězec.
{
"$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))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
concatOutput | String | prefix-5yj4yjf5mbg72 |
Následující příklad ukazuje, jak zkombinovat dvě pole.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
return | Pole | ["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"] |
contains(container, itemToFind)
Kontroluje, zda pole obsahuje hodnotu, objekt obsahuje klíč nebo řetězec obsahuje podřetězce. Porovnání řetězců se rozlišují malá a velká písmena. Při testování, pokud objekt obsahuje klíč, je však porovnání nerozlišující malá a velká písmena.
V Bicep použijte funkci contains .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
kontejner | Ano | pole, objekt nebo řetězec | Hodnota, která obsahuje hodnotu, kterou chcete najít. |
itemToFind | Ano | řetězec nebo int | Hodnota, kterou chcete najít. |
True
je-li položka nalezena; v opačném případě . False
Následující příklad ukazuje, jak používat obsahuje různé typy:
{
"$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')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
stringTrue | Bool | True |
stringFalse | Bool | False |
objectTrue | Bool | True |
objectFalse | Bool | False |
arrayTrue | Bool | True |
arrayFalse | Bool | False |
dataUri(stringToConvert)
Převede hodnotu na identifikátor URI dat.
V bicep použijte funkci dataUri .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToConvert | Ano | string | Hodnota, která se má převést na identifikátor URI dat. |
Řetězec formátovaný jako identifikátor URI dat.
Následující příklad převede hodnotu na identifikátor URI dat a převede identifikátor URI dat na řetězec.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"stringToTest": {
"type": "string",
"defaultValue": "Hello"
},
"dataFormattedString": {
"type": "string",
"defaultValue": "data:;base64,SGVsbG8sIFdvcmxkIQ=="
}
},
"resources": [],
"outputs": {
"dataUriOutput": {
"value": "[dataUri(parameters('stringToTest'))]",
"type": "string"
},
"toStringOutput": {
"type": "string",
"value": "[dataUriToString(parameters('dataFormattedString'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
dataUriOutput | String | data:text/plain; charset=utf8; base64,SGVsbG8= |
toStringOutput | String | Hello, World! |
dataUriToString(dataUriToConvert)
Převede hodnotu formátovanou datovým identifikátorem URI na řetězec.
V Bicep použijte funkci dataUriToString .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
dataUriToConvert | Ano | string | Hodnota identifikátoru URI dat, která se má převést. |
Řetězec obsahující převedenou hodnotu.
Následující příklad šablony převede hodnotu na identifikátor URI dat a převede identifikátor URI dat na řetězec.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"stringToTest": {
"type": "string",
"defaultValue": "Hello"
},
"dataFormattedString": {
"type": "string",
"defaultValue": "data:;base64,SGVsbG8sIFdvcmxkIQ=="
}
},
"resources": [],
"outputs": {
"dataUriOutput": {
"value": "[dataUri(parameters('stringToTest'))]",
"type": "string"
},
"toStringOutput": {
"type": "string",
"value": "[dataUriToString(parameters('dataFormattedString'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
dataUriOutput | String | data:text/plain; charset=utf8; base64,SGVsbG8= |
toStringOutput | String | Hello, World! |
empty(itemToTest)
Určuje, zda je pole, objekt nebo řetězec prázdné.
V Bicep použijte prázdnou funkci.
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
itemToTest | Ano | pole, objekt nebo řetězec | Hodnota, která se má zkontrolovat, jestli je prázdná. |
Vrátí True
, pokud je hodnota prázdná, False
jinak .
Následující příklad zkontroluje, zda pole, objekt a řetězec jsou prázdné.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayEmpty | Bool | True |
objectEmpty | Bool | True |
stringEmpty | Bool | True |
endsWith(stringToSearch, stringToFind)
Určuje, zda řetězec končí hodnotou. Porovnání nerozlišuje malá a velká písmena.
V Bicep použijte funkci endsWith .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToSearch | Ano | string | Hodnota obsahující položku, kterou chcete najít. |
stringToFind | Ano | string | Hodnota, kterou chcete najít. |
True
pokud poslední znak nebo znaky řetězce odpovídají hodnotě; v opačném případě . False
Následující příklad ukazuje, jak používat funkce startsWith
endsWith
:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"startsTrue": {
"type": "bool",
"value": "[startsWith('abcdef', 'ab')]"
},
"startsCapTrue": {
"type": "bool",
"value": "[startsWith('abcdef', 'A')]"
},
"startsFalse": {
"type": "bool",
"value": "[startsWith('abcdef', 'e')]"
},
"endsTrue": {
"type": "bool",
"value": "[endsWith('abcdef', 'ef')]"
},
"endsCapTrue": {
"type": "bool",
"value": "[endsWith('abcdef', 'F')]"
},
"endsFalse": {
"type": "bool",
"value": "[endsWith('abcdef', 'e')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
startsTrue | Bool | True |
startsCapTrue | Bool | True |
startsFalse | Bool | False |
endTrue | Bool | True |
endsCapTrue | Bool | True |
endFalse | Bool | False |
first(arg1)
Vrátí první znak řetězce nebo první prvek pole. Pokud je zadaný prázdný řetězec, výsledkem funkce bude prázdný řetězec. V případě prázdného pole vrátí null
funkce .
V Bicep použijte první funkci.
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | pole nebo řetězec | Hodnota pro načtení prvního prvku nebo znaku. |
Řetězec prvního znaku nebo typ (řetězec, int, pole nebo objekt) prvního prvku v poli.
Následující příklad ukazuje, jak použít první funkci s polem a řetězcem.
{
"$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')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayOutput | String | jeden |
stringOutput | String | O |
format(formatString, arg1, arg2, ...)
Vytvoří formátovaný řetězec ze vstupních hodnot.
V Bicep použijte funkci format .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
formatString | Ano | string | Složený formátovací řetězec. |
arg1 | Ano | řetězec, celé číslo nebo logická hodnota | Hodnota, která se má zahrnout do formátovaného řetězce. |
další argumenty | No | řetězec, celé číslo nebo logická hodnota | Do formátovaného řetězce se zahrnou další hodnoty. |
Pomocí této funkce můžete formátovat řetězec v šabloně. Používá stejné možnosti formátování jako metoda System.String.Format v .NET.
Následující příklad ukazuje, jak používat funkci formátu.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"greeting": {
"type": "string",
"defaultValue": "Hello"
},
"name": {
"type": "string",
"defaultValue": "User"
},
"numberToFormat": {
"type": "int",
"defaultValue": 8175133
}
},
"resources": [
],
"outputs": {
"formatTest": {
"type": "string",
"value": "[format('{0}, {1}. Formatted number: {2:N0}', parameters('greeting'), parameters('name'), parameters('numberToFormat'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
formatTest | String | Dobrý den, uživatel. Formátované číslo: 8 175 133 |
guid(baseString, ...)
Vytvoří hodnotu ve formátu globálně jedinečného identifikátoru na základě hodnot zadaných jako parametry.
V Bicep použijte funkci GUID .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
baseString | Ano | string | Hodnota použitá ve funkci hash k vytvoření identifikátoru GUID. |
další parametry podle potřeby | No | string | Můžete přidat tolik řetězců, kolik potřebujete k vytvoření hodnoty, která určuje úroveň jedinečnosti. |
Tato funkce je užitečná, když potřebujete vytvořit hodnotu ve formátu globálně jedinečného identifikátoru. Zadáte hodnoty parametrů, které omezují rozsah jedinečnosti výsledku. Můžete určit, jestli je název jedinečný až do předplatného, skupiny prostředků nebo nasazení.
Vrácená hodnota není náhodný řetězec, ale spíše výsledek funkce hash u parametrů. Vrácená hodnota je 36 znaků dlouhá. Není globálně jedinečný. Pokud chcete vytvořit nový identifikátor GUID, který není založený na této hodnotě hash parametrů, použijte funkci newGuid .
Následující příklady ukazují, jak pomocí identifikátoru GUID vytvořit jedinečnou hodnotu pro běžně používané úrovně.
Jedinečný obor předplatného
"[guid(subscription().subscriptionId)]"
Jedinečný obor pro skupinu prostředků
"[guid(resourceGroup().id)]"
Jedinečný obor nasazení pro skupinu prostředků
"[guid(resourceGroup().id, deployment().name)]"
Funkce guid
implementuje algoritmus z RFC 4122 §4.3. Původní zdroj lze najít v GuidUtility s některými úpravami.
Řetězec obsahující 36 znaků ve formátu globálně jedinečného identifikátoru.
Následující příklad vrátí výsledky z guid
:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {},
"variables": {},
"resources": [],
"outputs": {
"guidPerSubscription": {
"type": "string",
"value": "[guid(subscription().subscriptionId)]"
},
"guidPerResourceGroup": {
"type": "string",
"value": "[guid(resourceGroup().id)]"
},
"guidPerDeployment": {
"type": "string",
"value": "[guid(resourceGroup().id, deployment().name)]"
}
}
}
indexOf(stringToSearch, stringToFind)
Vrátí první pozici hodnoty v řetězci. Porovnání nerozlišuje malá a velká písmena.
V Bicep použijte funkci indexOf .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToSearch | Ano | string | Hodnota obsahující položku, kterou chcete najít. |
stringToFind | Ano | string | Hodnota, kterou chcete najít. |
Celé číslo, které představuje pozici položky, která se má najít. Hodnota je založená na nule. Pokud se položka nenajde, vrátí se hodnota -1.
Následující příklad ukazuje, jak používat funkce indexOf
lastIndexOf
:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"firstT": {
"type": "int",
"value": "[indexOf('test', 't')]"
},
"lastT": {
"type": "int",
"value": "[lastIndexOf('test', 't')]"
},
"firstString": {
"type": "int",
"value": "[indexOf('abcdef', 'CD')]"
},
"lastString": {
"type": "int",
"value": "[lastIndexOf('abcdef', 'AB')]"
},
"notFound": {
"type": "int",
"value": "[indexOf('abcdef', 'z')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
firstT | Int | 0 |
lastT | Int | 3 |
firstString | Int | 2 |
lastString | Int | 0 |
notFound | Int | -1 |
join(inputArray, delimiter)
Spojí pole řetězců do jednoho řetězce odděleného oddělovačem.
V Bicep použijte funkci join .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
inputArray | Ano | pole řetězce | Pole řetězce, který se má spojit. |
oddělovač | Ano | Oddělovač, který se má použít k rozdělení řetězce. |
Řetězec.
Následující příklad spojí vstupní pole řetězců s řetězci oddělenými pomocí různých oddělovačů.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"arrayString": [
"one",
"two",
"three"
]
},
"resources": [],
"outputs": {
"firstOutput": {
"type": "string",
"value": "[join(variables('arrayString'), ',')]"
},
"secondOutput": {
"type": "string",
"value": "[join(variables('arrayString'), ';')]"
}
}
}
Výstup z předchozího příkladu je:
Name | Typ | Hodnota |
---|---|---|
firstOutput | String | "jedna,dvě,tři" |
secondOutput | String | "jeden; Dva; tři" |
json(arg1)
Převede platný řetězec JSON na datový typ JSON. Další informace najdete v tématu funkce JSON.
V Bicep použijte funkci JSON .
last(arg1)
Vrátí poslední znak řetězce nebo poslední prvek pole.
V Bicep použijte poslední funkci.
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | pole nebo řetězec | Hodnota pro načtení posledního prvku nebo znaku. |
Řetězec posledního znaku nebo typ (řetězec, int, pole nebo objekt) posledního prvku v poli.
Následující příklad ukazuje, jak používat last
funkci s polem a řetězcem.
{
"$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')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayOutput | String | tři |
stringOutput | String | e |
lastIndexOf(stringToSearch, stringToFind)
Vrátí poslední pozici hodnoty v řetězci. Porovnání nerozlišuje malá a velká písmena.
V Bicep použijte funkci lastIndexOf .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToSearch | Ano | string | Hodnota obsahující položku, kterou chcete najít. |
stringToFind | Ano | string | Hodnota, kterou chcete najít. |
Celé číslo, které představuje poslední pozici položky, která se má najít. Hodnota je založená na nule. Pokud se položka nenajde, vrátí se hodnota -1.
Následující příklad ukazuje, jak používat funkce indexOf
lastIndexOf
:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"firstT": {
"type": "int",
"value": "[indexOf('test', 't')]"
},
"lastT": {
"type": "int",
"value": "[lastIndexOf('test', 't')]"
},
"firstString": {
"type": "int",
"value": "[indexOf('abcdef', 'CD')]"
},
"lastString": {
"type": "int",
"value": "[lastIndexOf('abcdef', 'AB')]"
},
"notFound": {
"type": "int",
"value": "[indexOf('abcdef', 'z')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
firstT | Int | 0 |
lastT | Int | 3 |
firstString | Int | 2 |
lastString | Int | 0 |
notFound | Int | -1 |
length(string)
Vrátí počet znaků v řetězci, prvky v poli nebo vlastnosti kořenové úrovně v objektu.
V Bicep použijte funkci délky .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
arg1 | Ano | pole, řetězec nebo objekt | Pole, které se má použít pro získání počtu prvků, řetězec, který se má použít pro získání počtu znaků, nebo objekt, který se má použít pro získání počtu vlastností kořenové úrovně. |
Int.
Následující příklad ukazuje, jak používat length
funkci s polem a řetězcem:
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayLength | Int | 3 |
stringLength | Int | 13 |
objectLength | Int | 4 |
newGuid()
Vrátí hodnotu ve formátu globálně jedinečného identifikátoru. Tuto funkci lze použít pouze ve výchozí hodnotě parametru.
V Bicep použijte funkci newGuid .
Tuto funkci můžete použít pouze ve výrazu pro výchozí hodnotu parametru. Použití této funkce kdekoli jinde v šabloně vrátí chybu. Funkce není povolená v jiných částech šablony, protože pokaždé, když je volána, vrátí jinou hodnotu. Nasazení stejné šablony se stejnými parametry by spolehlivě nezískuilo stejné výsledky.
Nová funkceGuid se liší od funkce GUID , protože nepřebírají žádné parametry. Když zavoláte identifikátor GUID se stejným parametrem, vrátí pokaždé stejný identifikátor. Pokud potřebujete spolehlivě vygenerovat stejný identifikátor GUID pro konkrétní prostředí, použijte identifikátor GUID. NewGuid použijte, když potřebujete pokaždé jiný identifikátor, například nasazení prostředků do testovacího prostředí.
Nová funkceGuid používá strukturu GUID v rozhraní .NET Framework k vygenerování globálně jedinečného identifikátoru.
Pokud použijete možnost opětovného nasazení dříve úspěšného nasazení a dřívější nasazení obsahuje parametr, který používá newGuid, parametr se znovu nevyhodnotuje. Místo toho se hodnota parametru z předchozího nasazení automaticky znovu použije v nasazení vrácení zpět.
V testovacím prostředí možná budete muset opakovaně nasazovat prostředky, které žijí jen na krátkou dobu. Místo vytváření jedinečných názvů můžete k vytvoření jedinečných názvů použít newGuid s uniqueString .
Při opětovném nasazení šablony, která pro výchozí hodnotu spoléhá na funkci newGuid, buďte opatrní. Když znovu nasadíte parametr a nezadáte hodnotu parametru, funkce se znovu zhodnocuje. Pokud chcete místo vytvoření nového prostředku aktualizovat existující prostředek, předejte hodnotu parametru z předchozího nasazení.
Řetězec obsahující 36 znaků ve formátu globálně jedinečného identifikátoru.
Následující příklad ukazuje parametr s novým identifikátorem.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"guidValue": {
"type": "string",
"defaultValue": "[newGuid()]"
}
},
"resources": [
],
"outputs": {
"guidOutput": {
"type": "string",
"value": "[parameters('guidValue')]"
}
}
}
Výstup z předchozího příkladu se pro každé nasazení liší, ale bude vypadat nějak takto:
Name | Typ | Hodnota |
---|---|---|
GuidOutput | string | b76a51fc-bd72-4a77-b9a2-3c29e7d2e551 |
Následující příklad používá newGuid
funkci k vytvoření jedinečného názvu účtu úložiště. Tato šablona může fungovat pro testovací prostředí, ve kterém existuje účet úložiště na krátkou dobu a není znovu nasazený.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"guidValue": {
"type": "string",
"defaultValue": "[newGuid()]"
}
},
"variables": {
"storageName": "[concat('storage', uniqueString(parameters('guidValue')))]"
},
"resources": [
{
"type": "Microsoft.Storage/storageAccounts",
"apiVersion": "2021-04-01",
"name": "[variables('storageName')]",
"location": "West US",
"sku": {
"name": "Standard_LRS"
},
"kind": "StorageV2",
"properties": {}
}
],
"outputs": {
"nameOutput": {
"type": "string",
"value": "[variables('storageName')]"
}
}
}
Výstup z předchozího příkladu se pro každé nasazení liší, ale bude vypadat nějak takto:
Name | Typ | Hodnota |
---|---|---|
nameOutput | string | storagenziwvyru7uxie |
padLeft(valueToPad, totalLength, paddingCharacter)
Vrátí řetězec zarovnaný doprava přidáním znaků doleva, dokud nedosáhne celkové zadané délky.
V Bicep použijte funkci padLeft .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
valueToPad | Ano | řetězec nebo int | Hodnota, která se má zarovnat doprava. |
totalLength | Ano | int | Celkový počet znaků ve vráceném řetězci. |
paddingCharacter | No | jeden znak | Znak, který se má použít pro odsazení doleva, dokud nedosáhnete celkové délky. Výchozí hodnota je mezera. |
Pokud je původní řetězec delší než počet znaků na panel, nepřidají se žádné znaky.
Řetězec s alespoň počtem zadaných znaků.
Následující příklad ukazuje, jak hodnotu parametru poskytovanou uživatelem přidat nulu, dokud nedosáhne celkového počtu znaků.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testString": {
"type": "string",
"defaultValue": "123"
}
},
"resources": [],
"outputs": {
"stringOutput": {
"type": "string",
"value": "[padLeft(parameters('testString'),10,'0')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
stringOutput | String | 0000000123 |
replace(originalString, oldString, newString)
Vrátí nový řetězec se všemi instancemi jednoho řetězce nahrazeným jiným řetězcem.
V Bicep použijte funkci replace .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
originalString | Ano | string | Hodnota, která má všechny instance jednoho řetězce nahrazen jiným řetězcem. |
oldString | Ano | string | Řetězec, který se má odebrat z původního řetězce. |
newString | Ano | string | Řetězec, který se má přidat místo odebraného řetězce. |
Řetězec s nahrazenými znaky.
Následující příklad ukazuje, jak odebrat všechny pomlčky z uživatelem poskytnutého řetězce a jak nahradit část řetězce jiným řetězcem.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testString": {
"type": "string",
"defaultValue": "123-123-1234"
}
},
"resources": [],
"outputs": {
"firstOutput": {
"type": "string",
"value": "[replace(parameters('testString'),'-', '')]"
},
"secondOutput": {
"type": "string",
"value": "[replace(parameters('testString'),'1234', 'xxxx')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
firstOutput | String | 1231231234 |
secondOutput | String | 123-123-xxxx |
skip(originalValue, numberToSkip)
Vrátí řetězec se všemi znaky za zadaným počtem znaků nebo pole se všemi prvky za zadaným počtem prvků.
V Bicep použijte funkci skip .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
originalValue | Ano | pole nebo řetězec | Pole nebo řetězec, které se mají použít pro přeskočení. |
numberToSkip | Ano | int | Počet prvků nebo znaků, které chcete přeskočit. Pokud je tato hodnota 0 nebo menší, vrátí se všechny prvky nebo znaky v hodnotě. Pokud je větší než délka pole nebo řetězce, vrátí se prázdné pole nebo řetězec. |
Pole nebo řetězec.
Následující příklad přeskočí zadaný počet prvků v poli a zadaný počet znaků v řetězci.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayOutput | Pole | ["tři"] |
stringOutput | String | dva tři |
split(inputString, delimiter)
Vrátí pole řetězců, které obsahují podřetězce vstupního řetězce, které jsou oddělené zadanými oddělovači.
V Bicep použijte rozdělenou funkci.
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
inputString | Ano | string | Řetězec, který chcete rozdělit. |
oddělovač | Ano | řetězec nebo pole řetězců | Oddělovač, který se má použít k rozdělení řetězce. |
Pole řetězců.
Následující příklad rozdělí vstupní řetězec čárkou a buď čárkou, nebo středníkem.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"firstString": {
"type": "string",
"defaultValue": "one,two,three"
},
"secondString": {
"type": "string",
"defaultValue": "one;two,three"
}
},
"variables": {
"delimiters": [ ",", ";" ]
},
"resources": [],
"outputs": {
"firstOutput": {
"type": "array",
"value": "[split(parameters('firstString'),',')]"
},
"secondOutput": {
"type": "array",
"value": "[split(parameters('secondString'),variables('delimiters'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
firstOutput | Pole | ["one", "two", "three"] |
secondOutput | Pole | ["one", "two", "three"] |
startsWith(stringToSearch, stringToFind)
Určuje, zda řetězec začíná hodnotou. Porovnání nerozlišuje malá a velká písmena.
V Bicep použijte funkci startsWith .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToSearch | Ano | string | Hodnota obsahující položku, kterou chcete najít. |
stringToFind | Ano | string | Hodnota, kterou chcete najít. |
True
pokud první znak nebo znaky řetězce odpovídají hodnotě; v opačném případě . False
Následující příklad ukazuje, jak používat funkce startsWith
endsWith
:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"startsTrue": {
"type": "bool",
"value": "[startsWith('abcdef', 'ab')]"
},
"startsCapTrue": {
"type": "bool",
"value": "[startsWith('abcdef', 'A')]"
},
"startsFalse": {
"type": "bool",
"value": "[startsWith('abcdef', 'e')]"
},
"endsTrue": {
"type": "bool",
"value": "[endsWith('abcdef', 'ef')]"
},
"endsCapTrue": {
"type": "bool",
"value": "[endsWith('abcdef', 'F')]"
},
"endsFalse": {
"type": "bool",
"value": "[endsWith('abcdef', 'e')]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
startsTrue | Bool | True |
startsCapTrue | Bool | True |
startsFalse | Bool | False |
endTrue | Bool | True |
endsCapTrue | Bool | True |
endFalse | Bool | False |
string(valueToConvert)
Převede zadanou hodnotu na řetězec.
V Bicep použijte řetězcovou funkci.
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
valueToConvert | Ano | Všechny | Hodnota, která se má převést na řetězec. Libovolný typ hodnoty lze převést, včetně objektů a polí. |
Řetězec převedené hodnoty.
Následující příklad ukazuje, jak převést různé typy hodnot na řetězce.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testObject": {
"type": "object",
"defaultValue": {
"valueA": 10,
"valueB": "Example Text"
}
},
"testArray": {
"type": "array",
"defaultValue": [
"a",
"b",
"c"
]
},
"testInt": {
"type": "int",
"defaultValue": 5
}
},
"resources": [],
"outputs": {
"objectOutput": {
"type": "string",
"value": "[string(parameters('testObject'))]"
},
"arrayOutput": {
"type": "string",
"value": "[string(parameters('testArray'))]"
},
"intOutput": {
"type": "string",
"value": "[string(parameters('testInt'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
objectOutput | String | {"valueA":10,"valueB":"Příklad textu"} |
arrayOutput | String | ["a","b","c"] |
intOutput | String | 5 |
substring(stringToParse, startIndex, length)
Vrátí podřetěr, který začíná na zadané pozici znaku a obsahuje zadaný počet znaků.
V bicep použijte funkci podřetědce .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToParse | Ano | string | Původní řetězec, ze kterého se extrahuje podřetězce. |
startIndex | No | int | Pozice počátečního znaku založeného na nule pro podřetězdce. |
length | No | int | Počet znaků podřetědce. Musí odkazovat na umístění v řetězci. Musí být nula nebo větší. Pokud tento argument vynecháte, vrátí se zbytek řetězce od počáteční pozice. |
Podřetětěr. Nebo prázdný řetězec, pokud je délka nula.
Funkce selže, pokud podřetězce přesahuje konec řetězce nebo pokud je délka menší než nula. Následující příklad selže s chybou "Parametry indexu a délky musí odkazovat na umístění v řetězci. Parametr indexu: 0, parametr length: 11, délka parametru řetězce: 10.
"parameters": {
"inputString": {
"type": "string",
"value": "1234567890"
}
}, "variables": {
"prefix": "[substring(parameters('inputString'), 0, 11)]"
}
Následující příklad extrahuje podřetěr z parametru.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testString": {
"type": "string",
"defaultValue": "one two three"
}
},
"resources": [],
"outputs": {
"substringOutput": {
"type": "string",
"value": "[substring(parameters('testString'), 4, 3)]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
substringOutput | String | dva |
take(originalValue, numberToTake)
Vrátí matici nebo řetězec. Matice má zadaný počet prvků od začátku pole. Řetězec má zadaný počet znaků od začátku řetězce.
V Bicep použijte funkci take .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
originalValue | Ano | pole nebo řetězec | Pole nebo řetězec, ze které mají být prvky odebrány. |
numberToTake | Ano | int | Počet prvků nebo znaků, které se mají vzít. Pokud je tato hodnota 0 nebo menší, vrátí se prázdné pole nebo řetězec. Pokud je větší než délka daného pole nebo řetězce, vrátí se všechny prvky v poli nebo řetězci. |
Pole nebo řetězec.
Následující příklad přebírá zadaný počet prvků z pole a znaky z řetězce.
{
"$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'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
arrayOutput | Pole | ["one", "two"] |
stringOutput | String | on |
toLower(stringToChange)
Převede zadaný řetězec na malá písmena.
V Bicep použijte funkci toLower .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToChange | Ano | string | Hodnota, která se má převést na malá písmena. |
Řetězec byl převeden na malá písmena.
Následující příklad převede hodnotu parametru na malá a velká písmena.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testString": {
"type": "string",
"defaultValue": "One Two Three"
}
},
"resources": [],
"outputs": {
"toLowerOutput": {
"type": "string",
"value": "[toLower(parameters('testString'))]"
},
"toUpperOutput": {
"type": "string",
"value": "[toUpper(parameters('testString'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
toLowerOutput | String | Jedna dva tři |
toUpperOutput | String | JEDNA DVA TŘI |
toUpper(stringToChange)
Převede zadaný řetězec na velká písmena.
V Bicep použijte funkci toUpper .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToChange | Ano | string | Hodnota, která se má převést na velká písmena. |
Řetězec byl převeden na velká písmena.
Následující příklad převede hodnotu parametru na malá a velká písmena.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testString": {
"type": "string",
"defaultValue": "One Two Three"
}
},
"resources": [],
"outputs": {
"toLowerOutput": {
"type": "string",
"value": "[toLower(parameters('testString'))]"
},
"toUpperOutput": {
"type": "string",
"value": "[toUpper(parameters('testString'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
toLowerOutput | String | Jedna dva tři |
toUpperOutput | String | JEDNA DVA TŘI |
trim(stringToTrim)
Odebere všechny počáteční a koncové prázdné znaky ze zadaného řetězce.
V Bicep použijte funkci trim .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToTrim | Ano | string | Hodnota, kterou chcete oříznout. |
Řetězec bez úvodních a koncových prázdných znaků.
Následující příklad oříznou prázdné znaky z parametru.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"parameters": {
"testString": {
"type": "string",
"defaultValue": " one two three "
}
},
"resources": [],
"outputs": {
"return": {
"type": "string",
"value": "[trim(parameters('testString'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
return | String | Jedna dva tři |
uniqueString(baseString, ...)
Vytvoří deterministický hashovací řetězec založený na hodnotách zadaných jako parametry.
V Bicep použijte funkci uniqueString .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
baseString | Ano | string | Hodnota použitá ve funkci hash k vytvoření jedinečného řetězce. |
další parametry podle potřeby | No | string | Můžete přidat tolik řetězců, kolik potřebujete k vytvoření hodnoty, která určuje úroveň jedinečnosti. |
Tato funkce je užitečná, když potřebujete vytvořit jedinečný název prostředku. Zadáte hodnoty parametrů, které omezují rozsah jedinečnosti výsledku. Můžete určit, jestli je název jedinečný až do předplatného, skupiny prostředků nebo nasazení.
Vrácená hodnota není náhodný řetězec, ale spíše výsledek funkce hash. Vrácená hodnota je dlouhá 13 znaků. Není globálně jedinečný. Můžete zkombinovat hodnotu s předponou z vaší konvence vytváření názvů a vytvořit smysluplný název. Následující příklad ukazuje formát vrácené hodnoty. Skutečná hodnota se liší podle zadaných parametrů.
tcvhiyu5h2o5o
Následující příklady ukazují, jak vytvořit uniqueString
jedinečnou hodnotu pro běžně používané úrovně.
Jedinečný obor předplatného
"[uniqueString(subscription().subscriptionId)]"
Jedinečný obor pro skupinu prostředků
"[uniqueString(resourceGroup().id)]"
Jedinečný obor nasazení pro skupinu prostředků
"[uniqueString(resourceGroup().id, deployment().name)]"
Následující příklad ukazuje, jak vytvořit jedinečný název pro účet úložiště na základě vaší skupiny prostředků. V rámci skupiny prostředků není název jedinečný, pokud je vytvořený stejným způsobem.
"resources": [{
"name": "[concat('storage', uniqueString(resourceGroup().id))]",
"type": "Microsoft.Storage/storageAccounts",
...
Pokud potřebujete vytvořit nový jedinečný název pokaždé, když nasadíte šablonu a nechcete aktualizovat prostředek, můžete použít funkci utcNow s uniqueString
. Tento přístup můžete použít v testovacím prostředí. Příklad: viz utcNow.
Řetězec obsahující 13 znaků.
Následující příklad vrátí výsledky z uniquestring
:
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"resources": [],
"outputs": {
"uniqueRG": {
"type": "string",
"value": "[uniqueString(resourceGroup().id)]"
},
"uniqueDeploy": {
"type": "string",
"value": "[uniqueString(resourceGroup().id, deployment().name)]"
}
}
}
uri(baseUri, relativeUri)
Vytvoří absolutní identifikátor URI kombinací baseUri a řetězce relativeUri.
V bicep použijte funkci URI .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
baseUri | Ano | string | Základní řetězec identifikátoru URI. Dbejte na to, abyste sledovali chování týkající se zpracování koncového lomítka (/ ), jak je popsáno v následující tabulce. |
relativeUri | Ano | string | Relativní řetězec identifikátoru URI, který se má přidat do základního řetězce identifikátoru URI. |
Pokud
baseUri
končí koncové lomítko, výsledek je jednodušebaseUri
následovanýrelativeUri
. PokudrelativeUri
také začíná počáteční lomítko, koncové lomítko a počáteční lomítko se zkombinuje do jednoho.Pokud
baseUri
koncové lomítko nekončí, stane se jedna ze dvou věcí.Pokud
baseUri
nemá vůbec žádná lomítka (kromě//
blízkosti přední strany), následujebaseUri
relativeUri
výsledek .Pokud
baseUri
má některá lomítka, ale nekončí lomítkem, vše od posledního lomítka se odeberebaseUri
a výsledekbaseUri
následujerelativeUri
.
Několik příkladů:
uri('http://contoso.org/firstpath', 'myscript.sh') -> http://contoso.org/myscript.sh
uri('http://contoso.org/firstpath/', 'myscript.sh') -> http://contoso.org/firstpath/myscript.sh
uri('http://contoso.org/firstpath/', '/myscript.sh') -> http://contoso.org/firstpath/myscript.sh
uri('http://contoso.org/firstpath/azuredeploy.json', 'myscript.sh') -> http://contoso.org/firstpath/myscript.sh
uri('http://contoso.org/firstpath/azuredeploy.json/', 'myscript.sh') -> http://contoso.org/firstpath/azuredeploy.json/myscript.sh
Úplné podrobnosti baseUri
a relativeUri
parametry jsou vyřešeny podle dokumentu RFC 3986 oddílu 5.
Řetězec představující absolutní identifikátor URI pro základní a relativní hodnoty.
Následující příklad ukazuje, jak vytvořit odkaz na vnořenou šablonu na základě hodnoty nadřazené šablony.
"templateLink": "[uri(deployment().properties.templateLink.uri, 'nested/azuredeploy.json')]"
Následující příklad šablony ukazuje, jak používat uri
, uriComponent
a uriComponentToString
.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"uriFormat": "[uri('http://contoso.com/resources/', 'nested/azuredeploy.json')]",
"uriEncoded": "[uriComponent(variables('uriFormat'))]"
},
"resources": [
],
"outputs": {
"uriOutput": {
"type": "string",
"value": "[variables('uriFormat')]"
},
"componentOutput": {
"type": "string",
"value": "[variables('uriEncoded')]"
},
"toStringOutput": {
"type": "string",
"value": "[uriComponentToString(variables('uriEncoded'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
uriOutput | String | http://contoso.com/resources/nested/azuredeploy.json |
componentOutput | String | http%3A%2F%2Fcontoso.com%2Fresources%2Fnested%2Fazuredeploy.json |
toStringOutput | String | http://contoso.com/resources/nested/azuredeploy.json |
uricomponent(stringToEncode)
Zakóduje identifikátor URI.
V bicep použijte funkci uriComponent .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
stringToEncode | Ano | string | Hodnota, která se má kódovat. |
Řetězec s hodnotou kódovanou identifikátorem URI.
Následující příklad šablony ukazuje, jak používat uri
, uriComponent
a uriComponentToString
.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"uriFormat": "[uri('http://contoso.com/resources/', 'nested/azuredeploy.json')]",
"uriEncoded": "[uriComponent(variables('uriFormat'))]"
},
"resources": [
],
"outputs": {
"uriOutput": {
"type": "string",
"value": "[variables('uriFormat')]"
},
"componentOutput": {
"type": "string",
"value": "[variables('uriEncoded')]"
},
"toStringOutput": {
"type": "string",
"value": "[uriComponentToString(variables('uriEncoded'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
uriOutput | String | http://contoso.com/resources/nested/azuredeploy.json |
componentOutput | String | http%3A%2F%2Fcontoso.com%2Fresources%2Fnested%2Fazuredeploy.json |
toStringOutput | String | http://contoso.com/resources/nested/azuredeploy.json |
uriComponentToString(uriEncodedString)
Vrátí řetězec s hodnotou zakódovanou identifikátorem URI.
V Bicep použijte funkci uriComponentToString .
Parametr | Požaduje se | Type | Popis |
---|---|---|---|
uriEncodedString | Ano | string | Zakódovaná hodnota identifikátoru URI, která se má převést na řetězec. |
Dekódovaný řetězec kódované hodnoty identifikátoru URI.
Následující příklad ukazuje, jak používat uri
, uriComponent
a uriComponentToString
.
{
"$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
"contentVersion": "1.0.0.0",
"variables": {
"uriFormat": "[uri('http://contoso.com/resources/', 'nested/azuredeploy.json')]",
"uriEncoded": "[uriComponent(variables('uriFormat'))]"
},
"resources": [
],
"outputs": {
"uriOutput": {
"type": "string",
"value": "[variables('uriFormat')]"
},
"componentOutput": {
"type": "string",
"value": "[variables('uriEncoded')]"
},
"toStringOutput": {
"type": "string",
"value": "[uriComponentToString(variables('uriEncoded'))]"
}
}
}
Výstup z předchozího příkladu s výchozími hodnotami je:
Name | Typ | Hodnota |
---|---|---|
uriOutput | String | http://contoso.com/resources/nested/azuredeploy.json |
componentOutput | String | http%3A%2F%2Fcontoso.com%2Fresources%2Fnested%2Fazuredeploy.json |
toStringOutput | String | http://contoso.com/resources/nested/azuredeploy.json |
- Popis oddílů v šabloně ARM najdete v tématu Vysvětlení struktury a syntaxe šablon ARM.
- Pokud chcete sloučit více šablon, přečtěte si téma Použití propojených a vnořených šablon při nasazování prostředků Azure.
- Pokud chcete iterovat zadaný počet opakování při vytváření typu prostředku, přečtěte si téma Iterace prostředků v šablonách ARM.
- Pokud chcete zjistit, jak nasadit šablonu, kterou jste vytvořili, přečtěte si téma Nasazení prostředků pomocí šablon ARM a Azure PowerShellu.