Freigeben über


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:

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

Truewenn das Element gefunden wird; 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 zurück True , wenn der Wert leer ist; andernfalls False.

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

Truewenn 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

Truewenn das erste 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 das Ergebnis mit einem nachgestellten Schrägstrich endet, folgt einfach baseUri das relativeUriErgebnis. Wenn relativeUri auch mit einem führenden Schrägstrich beginnt, wird der nachfolgende Schrägstrich und der führende Schrägstrich in einem kombiniert.

  • Wenn baseUri ein nachgestellter Schrägstrich nicht endet, geschieht eines von zwei Dingen.

    • Wenn baseUri überhaupt keine Schrägstriche vorhanden sind (abgesehen von der Nähe der // Vorderseite), wird baseUri das Ergebnis gefolgt von relativeUri.

    • Wenn baseUri einige Schrägstriche vorhanden sind, aber nicht mit einem Schrägstrich enden, wird alles aus dem letzten Schrägstrich entfernt baseUri und das Ergebnis folgtbaseUri.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/', '/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

Für vollständige Details werden die baseUri parameter relativeUri aufgelöst, wie in RFC 3986, Abschnitt 5 angegeben.

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