Zeichenfolgenfunktionen für ARM-Vorlagen

Resource Manager stellt die folgenden Funktionen für das Arbeiten mit Zeichenfolgen in Ihren Azure Resource Manager-Vorlagen (ARM-Vorlagen) bereit:

• base64
• base64ToJson
• base64ToString
• concat
• contains
• dataUri
• dataUriToString
• empty
• endsWith
• first
• format
• guid
• indexOf
• join
• json
• last
• lastIndexOf
• length
• newGuid
• padLeft
• replace
• skip
• split
• startsWith
• string
• substring
• take
• toLower
• toUpper
• trim
• uniqueString
• uri
• uriComponent
• uriComponentToString

Tipp

Wir empfehlen Bicep, weil es dieselben Funktionen wie ARM-Vorlagen bietet und die Syntax einfacher zu verwenden ist. Weitere Informationen finden Sie unter Bereichsfunktionen (scope).

base64

base64(inputString)

Rückkehr zur base64-Darstellung der Eingabezeichenfolge.

Verwenden Sie in Bicep die base64-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputString	Ja	Zeichenfolge	Der Wert, der als base64-Darstellung zurückgegeben wird.

Rückgabewert

Eine Zeichenfolge mit der base64-Darstellung.

Beispiele

Das folgende Beispiel zeigt die Verwendung der Funktion 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'))]"
    }
  }
}

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	one, two, three
toJsonOutput	Object	{"one": "a", "two": "b"}

base64ToJson

base64ToJson(base64Value)

Konvertiert eine base64-Darstellung in ein JSON-Objekt.

Verwenden Sie in Bicep die base64ToJson-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
base64Value	Ja	Zeichenfolge	Die in ein JSON-Objekt zu konvertierende base64-Darstellung.

Rückgabewert

Ein JSON-Objekt.

Beispiele

Das folgende Beispiel verwendet die Funktion base64ToJson, um einen base64-Wert zu konvertieren:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	one, two, three
toJsonOutput	Object	{"one": "a", "two": "b"}

base64ToString

base64ToString(base64Value)

Konvertiert eine base64-Darstellung in eine Zeichenfolge.

Verwenden Sie in Bicep die base64ToString-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
base64Value	Ja	Zeichenfolge	Die in eine Zeichenfolge zu konvertierende base64-Darstellung.

Rückgabewert

Eine Zeichenfolge des konvertierten base64-Werts.

Beispiele

Das folgende Beispiel verwendet die Funktion base64ToString, um einen base64-Wert zu konvertieren:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	one, two, three
toJsonOutput	Object	{"one": "a", "two": "b"}

concat

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

Kombiniert mehrere Zeichenfolgenwerte und gibt die verkettete Zeichenfolge zurück oder kombiniert mehrere Arrays und gibt das verkettete Array zurück.

Verwenden Sie in Bicep Zeichenfolgeninterpolation anstelle der concat()-Funktion, um die Lesbarkeit zu verbessern. In einigen Fällen, z. B. beim Ersetzen von Zeichenfolgen in mehrzeiligen Zeichenfolgen, müssen Sie jedoch möglicherweise auf die concat()-Funktion oder die replace()-Funktion zurückgreifen.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Zeichenfolge oder Array	Die erste Zeichenfolge oder das erste Array für die Verkettung.
mehr Argumente	Nein	Zeichenfolge oder Array	Weitere Zeichenketten oder Arrays in sequentieller Reihenfolge für die Verkettung.

Diese Funktion akzeptiert eine beliebige Anzahl von Argumenten und Zeichenfolgen oder Arrays für die Parameter. Sie können jedoch nicht sowohl Arrays als auch Zeichenfolgen für Parameter angeben. Zeichenfolgen werden nur mit anderen Zeichenfolgen verkettet.

Rückgabewert

Eine Zeichenfolge oder ein Array aus verketteten Werten.

Beispiele

Das folgende Beispiel zeigt, wie zwei Zeichenfolgenwerte kombiniert werden und eine verkettete Zeichenfolge zurückgeben.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
concatOutput	String	prefix-5yj4yjf5mbg72

Im folgenden Beispiel wird veranschaulicht, wie zwei Arrays kombiniert werden.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
return	Array	["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"]

contains

contains(container, itemToFind)

Überprüft, ob ein Array einen Wert enthält, ein Objekt einen Schlüssel enthält oder eine Zeichenfolge eine Teilzeichenfolge enthält. Die Groß-/Kleinschreibung wird beim Zeichenfolgenvergleich beachtet. Wenn Sie jedoch testen, ob ein Objekt einen Schlüssel enthält, wird die Groß-/Kleinschreibung beim Vergleich nicht beachtet.

Verwenden Sie in Bicep die contains-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
Container	Ja	Array, Objekt oder Zeichenfolge	Der Wert, der den zu suchenden Wert enthält.
itemToFind	Ja	Zeichenfolge oder ganze Zahl	Der zu suchende Wert.

Rückgabewert

True, wenn das Element gefunden wurde; andernfalls False.

Beispiele

Das folgende Beispiel zeigt die Verwendung von „contains“ mit unterschiedlichen Typen:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
stringTrue	Bool	True
stringFalse	Bool	False
objectTrue	Bool	True
objectFalse	Bool	False
arrayTrue	Bool	True
arrayFalse	Bool	False

dataUri

dataUri(stringToConvert)

Konvertiert einen Wert in einen Daten-URI.

Verwenden Sie in Bicep die dataUri-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToConvert	Ja	Zeichenfolge	Der Wert, der in einen Daten-URI konvertiert werden soll.

Rückgabewert

Eine als Daten-URI formatierte Zeichenfolge.

Beispiele

Das folgende Beispiel konvertiert einen Wert in einen Daten-URI und konvertiert einen Daten-URI in eine Zeichenfolge.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
dataUriOutput	String	data:text/plain;charset=utf8;base64,SGVsbG8=
toStringOutput	String	Hello, World!

dataUriToString

dataUriToString(dataUriToConvert)

Konvertiert einen als Daten-URI formatierten Wert in eine Zeichenfolge.

Verwenden Sie in Bicep die dataUriToString-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
dataUriToConvert	Ja	Zeichenfolge	Der zu konvertierende Daten-URI-Wert.

Rückgabewert

Eine Zeichenfolge, die den konvertierten Wert enthält.

Beispiele

Das folgende Beispiel konvertiert einen Wert in einen Daten-URI und konvertiert einen Daten-URI in eine Zeichenfolge.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
dataUriOutput	String	data:text/plain;charset=utf8;base64,SGVsbG8=
toStringOutput	String	Hello, World!

empty

empty(itemToTest)

Bestimmt, ob ein Array, Objekt oder eine Zeichenfolge leer ist.

Verwenden Sie in Bicep die empty-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
itemToTest	Ja	Array, Objekt oder Zeichenfolge	Der Wert, für den überprüft werden soll, ob er leer ist.

Rückgabewert

Gibt True zurück, wenn der Werte leer ist. Andernfalls wird False zurückgegeben.

Beispiele

Im folgenden Beispiel wird überprüft, ob ein Array, Objekt und eine Zeichenfolge leer sind.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayEmpty	Bool	True
objectEmpty	Bool	True
stringEmpty	Bool	True

endsWith

endsWith(stringToSearch, stringToFind)

Bestimmt, ob eine Zeichenfolge mit einem Wert endet. Bei dem Vergleich wird Groß- und Kleinschreibung nicht unterschieden.

Verwenden Sie in Bicep die endsWith-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToSearch	Ja	Zeichenfolge	Der Wert, der das zu suchende Element enthält.
stringToFind	Ja	Zeichenfolge	Der zu suchende Wert.

Rückgabewert

True, wenn das letzte Zeichen oder die letzten Zeichen der Zeichenfolge mit dem Wert übereinstimmen, andernfalls False.

Beispiele

Das folgende Beispiel zeigt, wie man die Funktionen startsWith und endsWith verwendet:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
startsTrue	Bool	True
startsCapTrue	Bool	True
startsFalse	Bool	False
endsTrue	Bool	True
endsCapTrue	Bool	True
endsFalse	Bool	False

first

first(arg1)

Gibt das erste Zeichen der Zeichenfolge oder das erste Element des Arrays zurück. Wenn eine leere Zeichenkette angegeben wird, gibt die Funktion eine leere Zeichenkette zurück. Bei einem leeren Array gibt die Funktion null zurück.

Verwenden Sie in Bicep die first-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array oder Zeichenfolge	Der Wert, dessen erstes Element oder Zeichen abgerufen wird.

Rückgabewert

Ein Zeichenfolgenwert, der dem letzten Zeichen entspricht, bzw. der Typ (Zeichenfolge, ganze Zahl, Array oder Objekt) des ersten Elements in einem Array.

Beispiele

Im folgenden Beispiel wird die Verwendung der first-Funktion mit einem Array und einer Zeichenfolge gezeigt.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	String	one
stringOutput	String	O

format

format(formatString, arg1, arg2, ...)

Erstellt eine formatierte Zeichenfolge aus Eingabewerten.

Verwenden Sie in Bicep die format-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
formatString	Ja	Zeichenfolge	Die zusammengesetzte Formatzeichenfolge.
arg1	Ja	Zeichenfolge, Integer oder boolescher Wert	Der Wert, der in die formatierte Zeichenfolge aufgenommen werden soll.
mehr Argumente	Nein	Zeichenfolge, Integer oder boolescher Wert	Mehrere Werte, die in die formatierte Zeichenfolge aufgenommen werden sollen.

Bemerkungen

Verwenden Sie diese Funktion zum Formatieren einer Zeichenfolge in Ihrer Vorlage. Sie verwendet die gleichen Formatierungsoptionen wie die System.String.Format-Methode in .NET.

Beispiele

Das folgende Beispiel zeigt die Verwendung der format-Funktion.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
formatTest	String	Hallo, Benutzer. Formatierte Zahl: 8.175.133

guid

guid(baseString, ...)

Erstellt einen Wert im Format eines Globally Unique Identifiers basierend auf den als Parameter angegebenen Werten.

Verwenden Sie in Bicep die guid-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
baseString	Ja	Zeichenfolge	Der in der Hashfunktion für die Erstellung des GUID verwendete Wert.
weitere Parameter nach Bedarf	Nein	Zeichenfolge	Sie können beliebig viele Zeichenfolgen hinzufügen, ganz wie sie zum Erstellen des Werts benötigt werden, der die Ebene der Eindeutigkeit angibt.

Bemerkungen

Diese Funktion ist hilfreich, wenn Sie einen Wert im Format eines Globally Unique Identifiers erstellen müssen. Sie geben Parameterwerte an, die den Eindeutigkeitsbereich für das Ergebnis einschränken. Sie können angeben, ob der Name bis hinunter zum Abonnement, zur Ressourcengruppe oder zur Bereitstellung eindeutig ist.

Der zurückgegebene Wert ist keine zufällige Zeichenfolge, sondern das Ergebnis einer Hashfunktion, die für die Parameter ausgeführt wurde. Der zurückgegebene Wert ist 36 Zeichen lang. Er ist nicht global eindeutig. Verwenden Sie die newGuid-Funktion, um eine neue GUID zu erstellen, die nicht auf diesem Hashwert der Parameter basiert.

Die folgenden Beispiele zeigen, wie Sie mithilfe des GUID einen eindeutigen Wert für häufig verwendete Ebenen erstellen können.

Eindeutige Zuordnung zum Abonnement

"[guid(subscription().subscriptionId)]"

Eindeutige Zuordnung zur Ressourcengruppe

"[guid(resourceGroup().id)]"

Eindeutige Zuordnung zur Bereitstellung für eine Ressourcengruppe

"[guid(resourceGroup().id, deployment().name)]"

Die guid-Funktion implementiert den Algorithmus aus RFC 4122 §4.3. Die ursprüngliche Quelle ist mit einigen Änderungen in GuidUtility zu finden.

Rückgabewert

Eine Zeichenfolge mit 36 Zeichen im Format eines Globally Unique Identifiers.

Beispiele

Das folgende Beispiel liefert Ergebnisse aus 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

indexOf(stringToSearch, stringToFind)

Gibt die erste Position eines Werts innerhalb einer Zeichenfolge zurück. Bei dem Vergleich wird Groß- und Kleinschreibung nicht unterschieden.

Verwenden Sie in Bicep die indexOf-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToSearch	Ja	Zeichenfolge	Der Wert, der das zu suchende Element enthält.
stringToFind	Ja	Zeichenfolge	Der zu suchende Wert.

Rückgabewert

Eine ganze Zahl, die die Position des zu suchenden Elements darstellt. Der Wert ist nullbasiert. Wenn das Element nicht gefunden wird, wird -1 zurückgegeben.

Beispiele

Das folgende Beispiel zeigt, wie man die Funktionen indexOf und lastIndexOf verwendet:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
firstT	Int	0
lastT	Int	3
firstString	Int	2
lastString	Int	0
NotFound	Int	-1

join

join(inputArray, delimiter)

Verknüpft ein Zeichenfolgenarray zu einer einzigen Zeichenfolge, getrennt durch ein Trennzeichen.

Verwenden Sie in Bicep die json-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputArray	Yes	Array von Zeichenfolgen	Ein Array aus zu verknüpfenden Zeichenfolgen.
Trennzeichen	Ja	Das Trennzeichen, das zum Teilen der Zeichenfolge verwendet werden soll.

Rückgabewert

Eine Zeichenfolge.

Beispiele

Das folgende Beispiel verknüpft das Eingabezeichenfolgenarray zu Zeichenfolgen, die mit verschiedenen Trennzeichen getrennt sind.

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

Die Ausgabe aus dem vorherigen Beispiel lautet wie folgt:

Name	type	Wert
firstOutput	String	"one,two,three"
secondOutput	String	"one;two;three"

json

json(arg1)

Konvertiert eine gültige JSON-Zeichenfolge in einen JSON-Datentyp. Weitere Informationen finden Sie unter json-Funktion.

Verwenden Sie in Bicep die json-Funktion.

last

last(arg1)

Gibt das letzte Zeichen der Zeichenfolge bzw. das letzte Element des Arrays zurück.

Verwenden Sie in Bicep die last-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array oder Zeichenfolge	Der Wert, dessen letztes Element oder Zeichen abgerufen wird.

Rückgabewert

Ein Zeichenfolgenwert, der dem letzten Zeichen entspricht, bzw. der Typ (Zeichenfolge, ganze Zahl, Array oder Objekt) des letzten Elements in einem Array.

Beispiele

Das folgende Beispiel zeigt, wie man die Funktion last mit einem Array und einer Zeichenkette verwendet.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	String	three
stringOutput	String	e

lastIndexOf

lastIndexOf(stringToSearch, stringToFind)

Gibt die letzte Position eines Werts innerhalb einer Zeichenfolge zurück. Bei dem Vergleich wird Groß- und Kleinschreibung nicht unterschieden.

Verwenden Sie in Bicep die lastIndexOf-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToSearch	Ja	Zeichenfolge	Der Wert, der das zu suchende Element enthält.
stringToFind	Ja	Zeichenfolge	Der zu suchende Wert.

Rückgabewert

Eine ganze Zahl, die die letzte Position des zu suchenden Elements darstellt. Der Wert ist nullbasiert. Wenn das Element nicht gefunden wird, wird -1 zurückgegeben.

Beispiele

Das folgende Beispiel zeigt, wie man die Funktionen indexOf und lastIndexOf verwendet:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
firstT	Int	0
lastT	Int	3
firstString	Int	2
lastString	Int	0
NotFound	Int	-1

length

length(string)

Gibt die Anzahl von Zeichen in einer Zeichenfolge, Elementen in einem Array oder Eigenschaften auf Stammebene in einem Objekt zurück.

Verwenden Sie in Bicep die length-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
arg1	Ja	Array, Zeichenfolge oder Objekt	Das Array, von dem die Anzahl der Elemente ermittelt werden soll, die Zeichenfolge, von der die Anzahl der Zeichen ermittelt werden soll, oder das Objekt, von dem die Anzahl der Eigenschaften auf Stammebene ermittelt werden soll.

Rückgabewert

Eine ganze Zahl.

Beispiele

Das folgende Beispiel zeigt, wie man die Funktion length mit einem Array und einer Zeichenkette verwendet:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arraylength	Int	3
stringLength	Int	13
objectLength	Int	4

newGuid

newGuid()

Gibt einen Wert im Format einer GUID (eindeutiger Bezeichner) zurück. Diese Funktion kann nur für den Standardwert eines Parameters verwendet werden.

Verwenden Sie in Bicep die newGuid-Funktion.

Bemerkungen

Sie können diese Funktion nur in einem Ausdruck für den Standardwert eines Parameters verwenden. Wenn diese Funktion an einer anderen Stelle in einer Vorlage verwendet wird, wird ein Fehler zurückgegeben. Die Funktion ist in anderen Teilen der Vorlage nicht zulässig, da bei jedem Aufruf ein anderer Wert zurückgegeben wird. Das Bereitstellen der gleichen Vorlage mit den gleichen Parametern würde nicht zuverlässig zu den gleichen Ergebnissen führen.

Im Gegensatz zur guid-Funktion verwendet die newGuid-Funktion keine Parameter. Wenn Sie die Funktion „guid“ mit demselben Parameter aufrufen, wird jedes Mal der gleiche Bezeichner zurückgegeben. Verwenden Sie die Funktion „guid“, wenn Sie die gleiche GUID für eine spezifische Umgebung zuverlässig generieren müssen. Verwenden Sie die Funktion „newGuid“, wenn Sie jedes Mal einen anderen Bezeichner benötigen, z. B. beim Bereitstellen von Ressourcen für eine Testumgebung.

Die newGuid-Funktion verwendet die Guid-Struktur im .NET Framework, um den global eindeutigen Bezeichner (GUID) zu generieren.

Wenn Sie die Option zum erneuten Bereitstellen einer vorherigen erfolgreichen Bereitstellung verwenden und die vorherige Bereitstellung einen Parameter enthält, der die Funktion „newGuid“ nutzt, wird dieser Parameter nicht erneut ausgewertet. Stattdessen wird der Parameterwert der vorherigen Bereitstellung in der Rollbackbereitstellung automatisch wiederverwendet.

In einer Testumgebung müssen Sie Ressourcen, die nur kurz gespeichert werden, möglicherweise wiederholt bereitstellen. Anstatt eindeutige Namen zu erstellen, können Sie die Funktion „newGuid“ mit uniqueString verwenden, um eindeutige Namen zu erstellen.

Seien Sie vorsichtig, wenn Sie eine Vorlage erneut bereitstellen, die die newGuid-Funktion für einen Standardwert nutzt. Wenn Sie die erneute Bereitstellung durchführen und keinen Wert für den Parameter bereitstellen, wird die Funktion erneut ausgewertet. Wenn Sie eine vorhandene Ressource aktualisieren möchten, anstatt eine neue zu erstellen, übergeben Sie den Parameterwert aus der früheren Bereitstellung.

Rückgabewert

Eine Zeichenfolge mit 36 Zeichen im Format eines Globally Unique Identifiers.

Beispiele

Im folgenden Beispiel wird ein Parameter mit einem neuen Bezeichner veranschaulicht.

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

Die Ausgabe des vorherigen Beispiels variiert bei jeder Bereitstellung. Sie sollte jedoch folgender ähneln:

Name	type	Wert
guidOutput	Zeichenfolge	b76a51fc-bd72-4a77-b9a2-3c29e7d2e551

Das folgende Beispiel verwendet die Funktion newGuid, um einen eindeutigen Namen für ein Speicherkonto zu erstellen. Diese Vorlage funktioniert möglicherweise in Testumgebungen, in denen das Speicherkonto nur für kurze Zeit vorhanden ist und nicht erneut bereitgestellt wird.

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

Die Ausgabe des vorherigen Beispiels variiert bei jeder Bereitstellung. Sie sollte jedoch folgender ähneln:

Name	type	Wert
nameOutput	Zeichenfolge	storagenziwvyru7uxie

padLeft

padLeft(valueToPad, totalLength, paddingCharacter)

Gibt eine rechtsbündig ausgerichtete Zeichenfolge zurück, indem links Zeichen hinzugefügt werden, bis die angegebene Gesamtlänge erreicht ist.

Verwenden Sie in Bicep die padLeft-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
valueToPad	Ja	Zeichenfolge oder ganze Zahl	Der Wert, der rechtsbündig ausgerichtet werden soll.
totalLength	Ja	INT	Die Gesamtzahl der Zeichen in der zurückgegebenen Zeichenfolge.
paddingCharacter	Nein	einzelnes Zeichen	Das Zeichen, das für das Auffüllen auf der linken Seite verwendet werden soll, bis die Gesamtlänge erreicht ist. Der Standardwert ist ein Leerzeichen.

Wenn die Länge der ursprünglichen Zeichenfolge die Anzahl der aufzufüllenden Zeichen überschreitet, werden keine Zeichen hinzugefügt.

Rückgabewert

Eine Zeichenfolge mit mindestens der angegebenen Zeichenanzahl.

Beispiele

Das folgende Beispiel zeigt, wie Sie den vom Benutzer angegebenen Parameterwert auffüllen, indem Sie das Nullzeichen hinzufügen, bis er die Gesamtzahl der Zeichen erreicht.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
stringOutput	String	0000000123

replace

replace(originalString, oldString, newString)

Gibt eine neue Zeichenfolge zurück, in der alle Instanzen einer Zeichenfolge durch eine andere Zeichenfolge ersetzt wurden.

Verwenden Sie in Bicep die replace-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
originalString	Ja	Zeichenfolge	Der Wert, für den alle Instanzen einer Zeichenfolge durch eine andere Zeichenfolge ersetzt wurden.
oldString	Ja	Zeichenfolge	Die Zeichenfolge, die aus der ursprünglichen Zeichenfolge entfernt werden soll.
newString	Ja	Zeichenfolge	Die Zeichenfolge, die anstelle der entfernten Zeichenfolge eingefügt werden soll.

Rückgabewert

Eine Zeichenfolge mit den ersetzten Zeichen.

Beispiele

Das folgende Beispiel zeigt, wie Sie aus einer von einem Benutzer bereitgestellten Zeichenfolge alle Gedankenstriche entfernen und einen Teil der Zeichenfolge durch eine andere Zeichenfolge ersetzen.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
firstOutput	String	1231231234
secondOutput	String	123-123-xxxx

skip

skip(originalValue, numberToSkip)

Gibt eine Zeichenfolge mit allen Zeichen gemäß der angegebenen Anzahl von Zeichen oder ein Array mit allen Elementen gemäß der angegebenen Anzahl von Elementen zurück.

Verwenden Sie in Bicep die skip-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
originalValue	Ja	Array oder Zeichenfolge	Array oder Zeichenfolge, wo Elemente übersprungen werden sollen.
numberToSkip	Ja	INT	Die Anzahl der zu überspringenden Elemente bzw. Zeichen. Wenn dieser Wert 0 (null) oder kleiner ist, werden alle Elemente oder Zeichen in dem Wert zurückgegeben. Ist er größer als die Länge des Arrays bzw. der Zeichenfolge, wird ein leeres Array bzw. eine leere Zeichenfolge zurückgegeben.

Rückgabewert

Ein Array oder eine Zeichenfolge.

Beispiele

Im folgenden Beispiel wird die angegebene Anzahl von Elementen im Array und Zeichen in der Zeichenfolge übersprungen.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	Array	["three"]
stringOutput	String	two three

split

split(inputString, delimiter)

Gibt ein Array mit Zeichenfolgen zurück, das die Teilzeichenfolgen der Eingabezeichenfolge getrennt durch die angegebenen Trennzeichen enthält.

Verwenden Sie in Bicep die split-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
inputString	Ja	Zeichenfolge	Die zu teilende Zeichenfolge.
Trennzeichen	Ja	Zeichenfolge oder Array von Zeichenfolgen	Das Trennzeichen, das zum Teilen der Zeichenfolge verwendet werden soll.

Rückgabewert

Ein Array der Zeichenfolgen.

Beispiele

Das folgende Beispiel trennt die Eingabezeichenfolge mit einem Komma und entweder mit einem Komma oder einem Semikolon.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
firstOutput	Array	["one", "two", "three"]
secondOutput	Array	["one", "two", "three"]

startsWith

startsWith(stringToSearch, stringToFind)

Stellt fest, ob eine Zeichenfolge mit einem bestimmten Wert beginnt. Bei dem Vergleich wird Groß- und Kleinschreibung nicht unterschieden.

Verwenden Sie in Bicep die startsWith-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToSearch	Ja	Zeichenfolge	Der Wert, der das zu suchende Element enthält.
stringToFind	Ja	Zeichenfolge	Der zu suchende Wert.

Rückgabewert

True, wenn das Zeichen oder die ersten Zeichen der Zeichenfolge mit dem Wert übereinstimmen, andernfalls False.

Beispiele

Das folgende Beispiel zeigt, wie man die Funktionen startsWith und endsWith verwendet:

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
startsTrue	Bool	True
startsCapTrue	Bool	True
startsFalse	Bool	False
endsTrue	Bool	True
endsCapTrue	Bool	True
endsFalse	Bool	False

Zeichenfolge

string(valueToConvert)

Konvertiert den angegebenen Wert in eine Zeichenfolge.

Verwenden Sie in Bicep die string-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
valueToConvert	Ja	Any	Der Wert, der in eine Zeichenfolge konvertiert werden soll. Werte aller Typen können konvertiert werden, auch Objekte und Arrays.

Rückgabewert

Eine Zeichenfolge des konvertierten Werts.

Beispiele

Das folgende Beispiel zeigt, wie verschiedene Arten von Werten in Zeichenketten umgewandelt werden können.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
objectOutput	String	{"valueA":10,"valueB":"Example Text"}
arrayOutput	String	["a","b","c"]
intOutput	String	5

substring

substring(stringToParse, startIndex, length)

Gibt eine Teilzeichenfolge zurück, die an der angegebenen Zeichenposition beginnt und die angegebene Anzahl von Zeichen enthält.

Verwenden Sie in Bicep die substring-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToParse	Ja	Zeichenfolge	Die ursprüngliche Zeichenfolge, aus der die Teilzeichenfolge extrahiert wird.
startIndex	Nein	INT	Die nullbasierte Anfangsposition für die Teilzeichenfolge.
length	Nein	INT	Die Anzahl der Zeichen der Teilzeichenfolge. Muss auf eine Position innerhalb der Zeichenfolge verweisen. Muss Null (0) oder größer sein. Wenn dieser Wert nicht angegeben wird, wird der Rest der Zeichenfolge von der Startposition zurückgegeben.

Rückgabewert

Die Teilzeichenfolge. Oder eine leere Zeichenfolge, wenn die Länge Null (0) entspricht.

Bemerkungen

Die Funktion schlägt fehl, wenn sich die Teilzeichenfolge über das Ende der Zeichenfolge erstreckt, oder wenn die Länge kleiner als Null (0) ist. Das folgende Beispiel führt zu dem Fehler „Die Parameter "index" und "length" müssen auf eine Position innerhalb der Zeichenfolge verweisen. Indexparameter: '0', Längenparameter: '11', Länge des Zeichenfolgenparameters: '10'.".

"parameters": {
  "inputString": {
    "type": "string",
    "value": "1234567890"
  }
}, "variables": {
  "prefix": "[substring(parameters('inputString'), 0, 11)]"
}

Beispiele

Im folgenden Beispiel wird eine Teilzeichenfolge aus einem Parameter extrahiert.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
substringOutput	String	two

take

take(originalValue, numberToTake)

Gibt ein Array oder eine Zeichenkette zurück. Ein Array hat die angegebene Anzahl von Elementen ab dem Beginn des Arrays. Eine Zeichenkette hat die angegebene Anzahl von Zeichen vom Anfang der Zeichenkette an.

Verwenden Sie in Bicep die take-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
originalValue	Ja	Array oder Zeichenfolge	Das Array bzw. die Zeichenfolge, wo die Elemente entnommen werden sollen.
numberToTake	Ja	INT	Die Anzahl der zu entnehmenden Elemente bzw. Zeichen. Ist dieser Wert 0 oder kleiner, wird ein leeres Array bzw. eine leere Zeichenfolge zurückgegeben. Ist er größer als die Länge des entsprechenden Arrays bzw. der Zeichenfolge, werden alle Elemente des Arrays bzw. der Zeichenfolge zurückgegeben.

Rückgabewert

Ein Array oder eine Zeichenfolge.

Beispiele

Im folgenden Beispiel wird die angegebene Anzahl von Elementen aus dem Array und Zeichen aus der Zeichenfolge entnommen.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
arrayOutput	Array	["one", "two"]
stringOutput	String	on

toLower

toLower(stringToChange)

Konvertiert die angegebene Zeichenfolge in Kleinbuchstaben.

Verwenden Sie in Bicep die toLower-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToChange	Ja	Zeichenfolge	Der Wert, der in Kleinbuchstaben konvertiert werden soll.

Rückgabewert

Die in Kleinbuchstaben konvertierte Zeichenfolge.

Beispiele

Im folgenden Beispiel wird ein Parameterwert in Klein- und Großbuchstaben konvertiert.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
toLowerOutput	String	one two three
toUpperOutput	String	ONE TWO THREE

toUpper

toUpper(stringToChange)

Konvertiert die angegebene Zeichenfolge in Großbuchstaben.

Verwenden Sie in Bicep die toUpper-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToChange	Ja	Zeichenfolge	Der Wert, der in Großbuchstaben konvertiert werden soll.

Rückgabewert

Die in Großbuchstaben konvertierte Zeichenfolge.

Beispiele

Im folgenden Beispiel wird ein Parameterwert in Klein- und Großbuchstaben konvertiert.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
toLowerOutput	String	one two three
toUpperOutput	String	ONE TWO THREE

trim

trim(stringToTrim)

Entfernt alle führenden und nachgestellten Leerzeichen aus der angegebenen Zeichenfolge.

Verwenden Sie in Bicep die trim-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToTrim	Ja	Zeichenfolge	Der zu kürzende Wert.

Rückgabewert

Die Zeichenfolge ohne vorangestellte oder nachstehende Leerzeichen.

Beispiele

Im folgenden Beispiel werden die Leerzeichen aus dem Parameter entfernt.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
return	String	one two three

uniqueString

uniqueString(baseString, ...)

Erstellt auf der Grundlage der als Parameter angegebenen Werte eine deterministische Hashzeichenfolge.

Verwenden Sie in Bicep die uniqueString-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
baseString	Ja	Zeichenfolge	Der Wert, der in der Hashfunktion verwendet wird, um eine eindeutige Zeichenfolge zu erstellen.
weitere Parameter nach Bedarf	Nein	Zeichenfolge	Sie können beliebig viele Zeichenfolgen hinzufügen, ganz wie sie zum Erstellen des Werts benötigt werden, der die Ebene der Eindeutigkeit angibt.

Bemerkungen

Diese Funktion ist hilfreich, wenn Sie einen eindeutigen Namen für eine Ressource erstellen müssen. Sie geben Parameterwerte an, die den Eindeutigkeitsbereich für das Ergebnis einschränken. Sie können angeben, ob der Name bis hinunter zum Abonnement, zur Ressourcengruppe oder zur Bereitstellung eindeutig ist.

Der zurückgegebene Wert ist keine zufällige Zeichenfolge, sondern das Ergebnis einer Hashfunktion. Der zurückgegebene Wert ist 13 Zeichen lang. Er ist nicht global eindeutig. Es empfiehlt sich, den Wert mit einem Präfix aus Ihrer Benennungskonvention zu kombinieren, um einen aussagekräftigen Namen zu erstellen. Im folgenden Beispiel wird das Format des zurückgegebenen Werts veranschaulicht. Der tatsächliche Wert variiert je nach den angegebenen Parametern.

tcvhiyu5h2o5o

Die folgenden Beispiele zeigen, wie Sie mithilfe der uniqueString einen eindeutigen Wert für häufig verwendete Ebenen erstellen können.

Eindeutige Zuordnung zum Abonnement

"[uniqueString(subscription().subscriptionId)]"

Eindeutige Zuordnung zur Ressourcengruppe

"[uniqueString(resourceGroup().id)]"

Eindeutige Zuordnung zur Bereitstellung für eine Ressourcengruppe

"[uniqueString(resourceGroup().id, deployment().name)]"

Das folgende Beispiel zeigt, wie Sie einen eindeutigen Namen für ein Speicherkonto auf Grundlage seiner Ressourcengruppe erstellen. Innerhalb der Ressourcengruppe ist der Name nicht eindeutig, wenn er auf die gleiche Weise erstellt wird.

"resources": [{
  "name": "[concat('storage', uniqueString(resourceGroup().id))]",
  "type": "Microsoft.Storage/storageAccounts",
  ...

Wenn Sie bei jeder Bereitstellung einer Vorlage einen neuen eindeutigen Namen erstellen müssen und die Ressource nicht aktualisieren möchten, können Sie die utcNow-Funktion mit uniqueString verwenden. Diesen Ansatz können Sie in einer Testumgebung verwenden. Ein Beispiel finden Sie unter utcNow.

Rückgabewert

Eine Zeichenfolge mit 13 Zeichen.

Beispiele

Im folgenden Beispiel werden Ergebnisse aus uniquestring zurückgegeben:

{
  "$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

uri(baseUri, relativeUri)

Erstellt einen absoluten URI durch Kombinieren der baseUri- und der relativeUri-Zeichenfolge.

Verwenden Sie in Bicep die uri-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
baseUri	Ja	Zeichenfolge	Die Zeichenfolge mit dem Basis-URI. Achten Sie auf das Verhalten bei der Behandlung des abschließenden Schrägstrichs (/), wie es in dieser Tabelle beschrieben ist.
relativeUri	Ja	Zeichenfolge	Der Zeichenfolge mit dem relativen URI, die der Zeichenfolge mit dem Basis-URI hinzugefügt werden soll.

• Wenn baseUri mit einem abschließenden Schrägstrich endet, ist das Ergebnis baseUri gefolgt von relativeUri.

• Wenn baseUri nicht mit einem abschließenden Schrägstrich endet, geschieht eines von zwei Dingen.

  • Wenn baseUri überhaupt keine Schrägstriche enthält (abgesehen von dem // am Anfang), ist das Ergebnis baseUri, gefolgt von relativeUri.

  • Wenn baseUri einige Schrägstriche aufweist, aber nicht mit einem Schrägstrich endet, wird alles ab dem letzten Schrägstrich aus baseUri entfernt, und das Ergebnis ist baseUri, gefolgt von relativeUri.

Im Folgenden finden Sie einige Beispiele:

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/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

Vollständige Details: Die Parameter baseUri und relativeUri werden wie in RFC 3986, Abschnitt 5 angegeben aufgelöst.

Rückgabewert

Eine Zeichenfolge, die den absoluten URI für den Basis- und relativen URI-Wert darstellt.

Beispiele

Im folgenden Beispiel wird veranschaulicht, wie basierend auf dem Wert der übergeordneten Vorlage eine Verknüpfung zu einer geschachtelten Vorlage erstellt wird.

"templateLink": "[uri(deployment().properties.templateLink.uri, 'nested/azuredeploy.json')]"

Die folgende Beispielvorlage zeigt, wie uri, uriComponent und uriComponentToString zu verwenden sind.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
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

uricomponent(stringToEncode)

Codiert einen URI.

Verwenden Sie in Bicep die uriComponent-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
stringToEncode	Ja	Zeichenfolge	Der zu codierende Wert.

Rückgabewert

Eine Zeichenfolge des als URI codierten Werts.

Beispiele

Die folgende Beispielvorlage zeigt, wie uri, uriComponent und uriComponentToString zu verwenden sind.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
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

uriComponentToString(uriEncodedString)

Gibt eine Zeichenfolge des als URI codierten Werts zurück.

Verwenden Sie in Bicep die uriComponentToString-Funktion.

Parameter

Parameter	Erforderlich	Type	BESCHREIBUNG
uriEncodedString	Ja	Zeichenfolge	Der als URI codierte Wert, der in eine Zeichenfolge konvertiert werden soll.

Rückgabewert

Eine decodierte Zeichenfolge des als URI codierten Werts.

Beispiele

Das folgende Beispiel zeigt, wie man uri, uriComponent und uriComponentToString verwendet.

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

Die Ausgabe aus dem vorherigen Beispiel mit den Standardwerten lautet:

Name	type	Wert
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

Nächste Schritte

• Eine Beschreibung der Abschnitte in einer ARM-Vorlage finden Sie unter Grundlegendes zur Struktur und Syntax von ARM-Vorlagen.
• Weitere Informationen zum Mergen mehrerer Vorlagen finden Sie unter Verwenden von verknüpften und geschachtelten Vorlagen bei der Bereitstellung von Azure-Ressourcen.
• Wenn Sie beim Erstellen eines Ressourcentyps eine angegebene Anzahl von Wiederholungen durchlaufen möchten, finden Sie weitere Informationen unter Ressourceniteration in ARM-Vorlagen.
• Informationen zum Bereitstellen der von Ihnen erstellten Vorlage finden Sie unter Bereitstellen von Ressourcen mit ARM-Vorlagen und Azure PowerShell.