Fonctions de chaîne pour les modèles Resource Manager

Resource Manager fournit les fonctions ci-dessous pour vous permettre d'utiliser des chaînes dans votre modèle Azure Resource Manager (modèle ARM) :

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

Conseil

Bicep est recommandé, car il offre les mêmes fonctionnalités que les modèles ARM et la syntaxe est plus facile à utiliser. Pour plus d’informations, consultez les fonctions de chaîne.

base64

base64(inputString)

Retourne la représentation en base 64 de la chaîne d'entrée.

Dans Bicep, utilisez la base64 fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
inputString	Oui	string	La valeur à retourner sous la forme d’une représentation en base64.

Valeur retournée

Une chaîne contenant la représentation en base64.

Exemples

L’exemple suivant explique comment utiliser la base64 fonction :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storageResourceGroup": {
      "type": "string"
    },
    "storageAccountName": {
      "type": "string"
    }
  },
  "resources": [],
  "outputs": {
    "ExistingStorage": {
      "type": "object",
      "value": "[reference(resourceId(parameters('storageResourceGroup'), 'Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-04-01')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	Un deux trois
toJsonOutput	Object	{"one » : « a », « two » : « b"}

base64ToJson

base64ToJson(base64Value)

Convertit une représentation en base64 en un objet JSON.

Dans Bicep, utilisez la base64ToJson fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
base64Value	Oui	string	La représentation en base64 à convertir en un objet JSON.

Valeur retournée

Un objet JSON.

Exemples

L’exemple suivant utilise la fonction base64ToJson pour convertir une valeur base64 :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storageResourceGroup": {
      "type": "string"
    },
    "storageAccountName": {
      "type": "string"
    }
  },
  "resources": [],
  "outputs": {
    "ExistingStorage": {
      "type": "object",
      "value": "[reference(resourceId(parameters('storageResourceGroup'), 'Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-04-01')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	Un deux trois
toJsonOutput	Object	{"one » : « a », « two » : « b"}

base64ToString

base64ToString(base64Value)

Convertit une représentation en base64 en une chaîne.

Dans Bicep, utilisez la base64ToString fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
base64Value	Oui	string	La représentation en base64 à convertir en une chaîne.

Valeur retournée

Une chaîne de la valeur base64 convertie.

Exemples

L’exemple suivant utilise la fonction base64ToString pour convertir une valeur base64 :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "parameters": {
    "storageResourceGroup": {
      "type": "string"
    },
    "storageAccountName": {
      "type": "string"
    }
  },
  "resources": [],
  "outputs": {
    "ExistingStorage": {
      "type": "object",
      "value": "[reference(resourceId(parameters('storageResourceGroup'), 'Microsoft.Storage/storageAccounts', parameters('storageAccountName')), '2021-04-01')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	Un deux trois
toJsonOutput	Object	{"one » : « a », « two » : « b"}

concat

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

Combine plusieurs valeurs de chaîne et retourne la chaine concaténée, ou combine plusieurs tableaux et retourne le tableau concaténé.

Dans Bicep, utilisez une interpolation de chaîne plutôt que la fonction concat() pour améliorer la lisibilité. Toutefois, dans certains cas, comme le remplacement de chaîne dans des chaînes multilignes, vous devrez peut-être revenir à l’aide de la concat() fonction ou de la replace() fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	chaîne ou tableau	Première chaîne ou premier tableau pour la concaténation.
arguments supplémentaires	Non	chaîne ou tableau	Chaînes ou tableaux supplémentaires en ordre séquentiel pour la concaténation.

Cette fonction peut prendre n’importe quel nombre d’arguments et accepter des chaînes ou des tableaux pour les paramètres. Toutefois, vous ne pouvez pas fournir à la fois des tableaux et des chaînes pour les paramètres. Les chaînes sont concaténées uniquement avec d’autres chaînes.

Valeur retournée

Chaîne ou tableau de valeurs concaténées.

Exemples

L’exemple suivant montre comment combiner deux valeurs de chaîne et retourner une chaîne concaténée :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
concatOutput	String	prefix-5yj4yjf5mbg72

L’exemple suivant montre comment combiner deux tableaux :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
return	Array	["1-1", "1-2", "1-3", "2-1", "2-2", "2-3"]

contains

contains(container, itemToFind)

Vérifie si un tableau contient une valeur, qu’un objet contient une clé ou qu’une chaîne contient une sous-chaîne. La comparaison de chaînes est sensible à la casse. Cependant, quand vous testez si un objet contient une clé, la comparaison n’est pas sensible à la casse.

Dans Bicep, utilisez la contains fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
conteneur	Oui	tableau, objet ou chaîne	La valeur qui contient la valeur à rechercher.
itemToFind	Oui	chaîne ou entier	La valeur à trouver.

Valeur retournée

True si l’élément est trouvé ; sinon, False.

Exemples

L’exemple suivant montre comment utiliser contains avec différents types :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
stringTrue	Bool	True
stringFalse	Bool	False
objectTrue	Bool	True
objectFalse	Bool	False
arrayTrue	Bool	True
arrayFalse	Bool	False

dataUri

dataUri(stringToConvert)

Convertit une valeur en un URI de données.

Dans Bicep, utilisez la dataUri fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToConvert	Oui	string	Valeur à convertir en URI de données.

Valeur retournée

Une chaîne formatée en tant qu’URI de données.

Exemples

L’exemple suivant convertit une valeur en URI de données et un URI de données en chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
dataUriOutput	String	data: texte/brut;jeu de caractèresdata:text/plain;charset=utf8;base64,SGVsbG8=
toStringOutput	String	Salut tout le monde!

dataUriToString

dataUriToString(dataUriToConvert)

Convertit une valeur formatée en URI de données en chaîne.

Dans Bicep, utilisez la dataUriToString fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
dataUriToConvert	Oui	string	Valeur d’URI de données à convertir.

Valeur retournée

Chaîne contenant la valeur convertie.

Exemples

L’exemple de modèle suivant convertit une valeur en URI de données et un URI de données en chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
dataUriOutput	String	data: texte/brut;jeu de caractèresdata:text/plain;charset=utf8;base64,SGVsbG8=
toStringOutput	String	Salut tout le monde!

empty

empty(itemToTest)

Détermine si un tableau, un objet ou une chaîne est vide.

Dans Bicep, utilisez la empty fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
itemToTest	Oui	tableau, objet ou chaîne	Valeur à vérifier pour voir si elle est vide.

Valeur retournée

Retourne True si la valeur est vide ; sinon, False.

Exemples

L’exemple suivant vérifie si un tableau, un objet et une chaîne sont vides :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
arrayEmpty	Bool	True
objectEmpty	Bool	True
stringEmpty	Bool	True

endsWith

endsWith(stringToSearch, stringToFind)

Détermine si une chaîne se termine par une valeur. La comparaison respecte la casse.

Dans Bicep, utilisez la endsWith fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToSearch	Oui	string	La valeur qui contient l’élément à rechercher.
stringToFind	Oui	string	La valeur à trouver.

Valeur retournée

True si le dernier caractère ou les caractères de la chaîne correspondent à la valeur ; sinon, False.

Exemples

L'exemple suivant montre comment utiliser les fonctions startsWith et endsWith :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "startsTrue": {
      "type": "bool",
      "value": "[startsWith('abcdef', 'ab')]"
    },
    "startsCapTrue": {
      "type": "bool",
      "value": "[startsWith('abcdef', 'A')]"
    },
    "startsFalse": {
      "type": "bool",
      "value": "[startsWith('abcdef', 'e')]"
    },
    "endsTrue": {
      "type": "bool",
      "value": "[endsWith('abcdef', 'ef')]"
    },
    "endsCapTrue": {
      "type": "bool",
      "value": "[endsWith('abcdef', 'F')]"
    },
    "endsFalse": {
      "type": "bool",
      "value": "[endsWith('abcdef', 'e')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
startsTrue	Bool	True
startsCapTrue	Bool	True
startsFalse	Bool	False
endsTrue	Bool	True
endsCapTrue	Bool	True
endsFalse	Bool	False

first

first(arg1)

Retourne le premier caractère de la chaîne ou le premier élément du tableau. Si une chaîne vide est donnée, la fonction produit une chaîne vide. Dans le cas d’un tableau vide, la fonction retourne null.

Dans Bicep, utilisez la first fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau ou chaîne	La valeur permettant de récupérer le premier élément ou caractère.

Valeur retournée

Chaîne du premier caractère ou du type (chaîne, int, tableau ou objet) du premier élément d’un tableau.

Exemples

L’exemple suivant montre comment utiliser la first fonction avec un tableau et une chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
arrayOutput	String	one
stringOutput	String	O

format

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

Crée une chaîne mise en forme à partir des valeurs d’entrée.

Dans Bicep, utilisez la format fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
formatString	Oui	string	Chaîne de format composite.
arg1	Oui	chaîne, entier ou valeur booléenne	Valeur à inclure dans la chaîne mise en forme.
arguments supplémentaires	Non	chaîne, entier ou valeur booléenne	Valeurs supplémentaires à inclure dans la chaîne mise en forme.

Notes

Utilisez cette fonction pour mettre en forme une chaîne dans votre modèle. Cette fonction utilise les mêmes options de mise en forme que la méthode System.String.Format dans .NET.

Exemples

L’exemple suivant explique comment utiliser la format fonction :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
formatTest	String	Bonjour. Nombre mis en forme : 8 175 133

guid

guid(baseString, ...)

Crée une valeur sous la forme d’un identificateur global unique basé sur les valeurs fournies comme paramètres.

Dans Bicep, utilisez la guid fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
baseString	Oui	string	Valeur utilisée dans la fonction de hachage pour créer le GUID.
paramètres supplémentaires le cas échéant	Non	string	Vous pouvez ajouter autant de chaînes que nécessaire pour créer la valeur qui spécifie le niveau d’unicité.

Notes

Cette fonction est utile quand vous devez créer une valeur sous la forme d’un identificateur global unique. Vous fournissez des valeurs de paramètre qui limitent l’étendue d’unicité pour le résultat. Vous pouvez spécifier si le nom est unique en abonnement, groupe de ressources ou déploiement.

La valeur retournée n’est pas une chaîne aléatoire, mais le résultat d’une fonction de hachage exécutée sur les paramètres. La valeur renvoyée comprend 36 caractères. Elle n’est pas globalement unique. Pour créer un GUID qui n’est pas basé sur cette valeur de hachage des paramètres, utilisez la newGuid fonction.

Les exemples suivants montrent comment utiliser guid pour créer une valeur unique pour les niveaux couramment utilisés :

Unique limité à l’abonnement

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

Unique limité au groupe de ressources

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

Unique limité au déploiement pour un groupe de ressources

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

La fonction guid implémente l’algorithme à partir de RFC 4122 §4.3. La source d’origine se trouve dans GuidUtility avec quelques modifications. Dans l’implémentation de la guid() fonction, la namespaceId valeur est définie 11fb06fb-712d-4ddd-98c7-e71bbd588830sur , et la version valeur est définie 5sur . La valeur est générée en convertissant chaque paramètre de la guid() fonction en chaîne et en concaténant celles-ci en - tant que délimiteurs.

Valeur retournée

Chaîne contenant 36 caractères sous la forme d’un identificateur global unique.

Exemples

Cet exemple retourne des résultats de 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)

Retourne la première position d’une valeur dans une chaîne. La comparaison respecte la casse.

Dans Bicep, utilisez la indexOf fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToSearch	Oui	string	La valeur qui contient l’élément à rechercher.
stringToFind	Oui	string	La valeur à trouver.

Valeur retournée

Entier qui représente la position de l’élément à rechercher. La valeur est basée sur zéro. Si l’élément est introuvable, la valeur -1 est retournée.

Exemples

L'exemple suivant montre comment utiliser les fonctions indexOf et lastIndexOf :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "firstT": {
      "type": "int",
      "value": "[indexOf('test', 't')]"
    },
    "lastT": {
      "type": "int",
      "value": "[lastIndexOf('test', 't')]"
    },
    "firstString": {
      "type": "int",
      "value": "[indexOf('abcdef', 'CD')]"
    },
    "lastString": {
      "type": "int",
      "value": "[lastIndexOf('abcdef', 'AB')]"
    },
    "notFound": {
      "type": "int",
      "value": "[indexOf('abcdef', 'z')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
firstT	Int	0
lastT	Int	3
firstString	Int	2
lastString	Int	0
notFound	Int	-1

join

join(inputArray, delimiter)

Joint un tableau de chaînes à une chaîne unique, séparés à l’aide d’un délimiteur.

Dans Bicep, utilisez la join fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
inputArray	Oui	tableau de chaînes	Tableau de chaînes à joindre.
delimiter	Oui	Le séparateur à utiliser pour fractionner la chaîne.

Valeur retournée

Chaîne.

Exemples

L’exemple suivant joint le tableau de chaînes d’entrée en chaînes délimitées par différents délimiteurs :

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

La sortie de l’exemple précédent est :

Nom	Type	Valeur
firstOutput	String	« one,two,three »
secondOutput	String	« one;two;three »

json

json(arg1)

Convertit une chaîne JSON valide en un type de données JSON. Pour plus d’informations, consultez json la fonction.

Dans Bicep, utilisez la json fonction.

last

last(arg1)

Retourne le dernier caractère de la chaîne ou le dernier élément du tableau.

Dans Bicep, utilisez la last fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau ou chaîne	La valeur permettant de récupérer le dernier élément ou caractère.

Valeur retournée

Chaîne du dernier caractère ou type (chaîne, entier, tableau ou objet) du dernier élément d’un tableau.

Exemples

L’exemple suivant montre comment utiliser la last fonction avec un tableau et une chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
arrayOutput	String	three
stringOutput	String	e

lastIndexOf

lastIndexOf(stringToSearch, stringToFind)

Retourne la dernière position d’une valeur dans une chaîne. La comparaison respecte la casse.

Dans Bicep, utilisez la lastIndexOf fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToSearch	Oui	string	La valeur qui contient l’élément à rechercher.
stringToFind	Oui	string	La valeur à trouver.

Valeur retournée

Entier qui représente la dernière position de l’élément à rechercher. La valeur est basée sur zéro. Si l’élément est introuvable, la valeur -1 est retournée.

Exemples

L'exemple suivant montre comment utiliser les fonctions indexOf et lastIndexOf :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "firstT": {
      "type": "int",
      "value": "[indexOf('test', 't')]"
    },
    "lastT": {
      "type": "int",
      "value": "[lastIndexOf('test', 't')]"
    },
    "firstString": {
      "type": "int",
      "value": "[indexOf('abcdef', 'CD')]"
    },
    "lastString": {
      "type": "int",
      "value": "[lastIndexOf('abcdef', 'AB')]"
    },
    "notFound": {
      "type": "int",
      "value": "[indexOf('abcdef', 'z')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
firstT	Int	0
lastT	Int	3
firstString	Int	2
lastString	Int	0
notFound	Int	-1

length

length(string)

Retourne le nombre d’éléments d’un tableau, les caractères d’une chaîne ou les propriétés au niveau de la racine d’un objet.

Dans Bicep, utilisez la length fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
arg1	Oui	tableau, chaîne ou objet	Tableau à utiliser pour l’obtention du nombre d’éléments, ou chaîne à utiliser pour l’obtention du nombre de caractères, ou l’objet à utiliser pour l’obtention du nombre de propriétés au niveau de la racine.

Valeur retournée

Un entier.

Exemples

L’exemple suivant montre comment utiliser la length fonction avec un tableau et une chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
arrayLength	Int	3
stringLength	Int	13
objectLength	Int	4

newGuid

newGuid()

Retourne une valeur sous la forme d’un identificateur global unique. Cette fonction peut uniquement être utilisée dans la valeur par défaut d’un paramètre.

Dans Bicep, utilisez la newGuid fonction.

Notes

Vous pouvez uniquement utiliser cette fonction dans une expression pour la valeur par défaut d’un paramètre. Son utilisation partout ailleurs dans un modèle retourne une erreur. La fonction n’est pas autorisée dans d’autres parties du modèle, car elle retourne une valeur différente chaque fois qu’elle est appelée. Le déploiement du même modèle avec les mêmes paramètres ne produit pas forcément les mêmes résultats.

La fonction newGuid diffère de la guid fonction, car elle ne prend aucun paramètre. Quand vous appelez la fonction guid avec le même paramètre, elle retourne toujours le même identificateur. Utilisez guid quand vous devez générer invariablement le même GUID dans un environnement spécifique. Utilisez newGuid pour générer un identificateur différent chaque fois, par exemple pour le déploiement de ressources dans un environnement de test.

La fonction newGuid utilise la structure Guid dans le .NET Framework pour générer l’identificateur global unique.

Si vous utilisez l’option de redéploiement d’un déploiement réussi précédemment , où le déploiement précédent inclut un paramètre qui utilise newGuid, le paramètre n’est pas évalué à nouveau. Au lieu de cela, le déploiement de restauration réutilise automatiquement la valeur du paramètre à partir du déploiement précédent.

Dans un environnement de test, vous devrez peut-être déployer à plusieurs reprises des ressources utilisables uniquement pendant une courte période. Au lieu de construire des noms uniques, vous pouvez utiliser newGuid pour uniqueString créer des noms uniques.

Veillez à redéployer un modèle qui s’appuie sur la newGuid fonction pour une valeur par défaut. Si vous effectuez un tel déploiement sans fournir de valeur pour le paramètre, la fonction est réévaluée. Si vous souhaitez mettre à jour une ressource existante au lieu d’en créer une autre, passez la valeur du paramètre qui était utilisée dans le déploiement précédent.

Valeur retournée

Chaîne contenant 36 caractères sous la forme d’un identificateur global unique.

Exemples

L’exemple suivant montre un paramètre avec un nouvel identificateur :

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

La sortie de l’exemple précédent varie pour chaque déploiement, mais elle sera semblable à celle-ci :

Nom	Type	Valeur
guidOutput	string	b76a51fc-bd72-4a77-b9a2-3c29e7d2e551

L’exemple suivant utilise la fonction newGuid pour créer un nom unique de compte de stockage. Ce modèle peut fonctionner pour l’environnement de test où le compte de stockage existe pendant une courte période et n’est pas déployé à nouveau :

{
  "$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": "2025-06-01",
      "name": "[variables('storageName')]",
      "location": "West US",
      "sku": {
        "name": "Standard_LRS"
      },
      "kind": "StorageV2",
      "properties": {}
    }
  ],
  "outputs": {
    "nameOutput": {
      "type": "string",
      "value": "[variables('storageName')]"
    }
  }
}

La sortie de l’exemple précédent varie pour chaque déploiement, mais elle sera semblable à celle-ci :

Nom	Type	Valeur
nameOutput	string	storagenziwvyru7uxie

padLeft

padLeft(valueToPad, totalLength, paddingCharacter)

Renvoie une chaîne alignée à droite en lui ajoutant des caractères sur la gauche jusqu’à ce que la longueur totale spécifiée ait été atteinte.

Dans Bicep, utilisez la padLeft fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
valeur_à_remplir	Oui	chaîne ou entier	Valeur à aligner à droite.
longueur_totale	Oui	int	Nombre total de caractères de la chaîne renvoyée.
caractère_de_remplissage	Non	caractère unique	Caractère de remplissage à insérer sur la gauche jusqu’à ce que la longueur totale soit atteinte. La valeur par défaut est un espace.

Si la chaîne d’origine est plus longue que le nombre de caractères de remplissage, aucun caractère n’est ajouté.

Valeur retournée

Chaîne avec au moins le nombre de caractères spécifié.

Exemples

L’exemple suivant montre comment ajouter le caractère zéro jusqu’à ce qu’il atteigne le nombre total de caractères pour remplir la valeur de paramètre fournie par l’utilisateur :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
stringOutput	String	0000000123

remplacer

replace(originalString, oldString, newString)

Renvoie une nouvelle chaîne dans laquelle toutes les instances d’une chaîne ont été remplacées par une autre.

Dans Bicep, utilisez la replace fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
chaîne_initiale	Oui	string	La valeur qu’ont toutes les instances d’une chaîne ont été remplacées par une autre.
oldString	Oui	string	Chaîne à supprimer de la chaîne initiale.
newString	Oui	string	Chaîne à ajouter à la place de la chaîne supprimée.

Valeur retournée

Chaîne contenant les caractères remplacés.

Exemples

L’exemple suivant montre comment supprimer tous les tirets d’une chaîne fournie par l’utilisateur et comment remplacer une partie de la chaîne par une autre :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
firstOutput	String	1231231234
secondOutput	String	123-123-xxxx

skip

skip(originalValue, numberToSkip)

Retourne une chaîne avec tous les caractères après le nombre spécifié de caractères, ou un tableau avec tous les éléments après le nombre spécifié d’éléments.

Dans Bicep, utilisez la skip fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
originalValue	Oui	tableau ou chaîne	Tableau ou chaîne à utiliser pour ignorer les caractères.
numberToSkip	Oui	int	Nombre d’éléments ou de caractères à ignorer. Si cette valeur est inférieure ou égale à 0, tous les éléments ou caractères de la valeur sont renvoyés. Si elle est supérieure à la longueur du tableau ou de la chaîne, un tableau ou une chaîne vide est retourné.

Valeur retournée

Tableau ou chaîne.

Exemples

L’exemple suivant ignore le nombre spécifié d’éléments dans le tableau et le nombre spécifié de caractères dans une chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
arrayOutput	Array	["three"]
stringOutput	String	deux trois

split

split(inputString, delimiter)

Renvoie un tableau de chaînes qui contient les sous-chaînes de la chaîne d’entrée séparées par les délimiteurs spécifiés.

Dans Bicep, utilisez la split fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
inputString	Oui	string	Chaîne à fractionner.
delimiter	Oui	chaîne ou tableau de chaînes	Le séparateur à utiliser pour fractionner la chaîne.

Valeur retournée

Tableau de chaînes.

Exemples

L’exemple suivant fractionne la chaîne d’entrée avec une virgule et la chaîne suivante avec une virgule ou un point-virgule :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
firstOutput	Array	["one », « two », « three"]
secondOutput	Array	["one », « two », « three"]

startsWith

startsWith(stringToSearch, stringToFind)

Détermine si une chaîne commence par une valeur. La comparaison respecte la casse.

Dans Bicep, utilisez la startsWith fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToSearch	Oui	string	La valeur qui contient l’élément à rechercher.
stringToFind	Oui	string	La valeur à trouver.

Valeur retournée

True si le premier caractère ou les caractères de la chaîne correspondent à la valeur ; sinon, False.

Exemples

L'exemple suivant montre comment utiliser les fonctions startsWith et endsWith :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "startsTrue": {
      "type": "bool",
      "value": "[startsWith('abcdef', 'ab')]"
    },
    "startsCapTrue": {
      "type": "bool",
      "value": "[startsWith('abcdef', 'A')]"
    },
    "startsFalse": {
      "type": "bool",
      "value": "[startsWith('abcdef', 'e')]"
    },
    "endsTrue": {
      "type": "bool",
      "value": "[endsWith('abcdef', 'ef')]"
    },
    "endsCapTrue": {
      "type": "bool",
      "value": "[endsWith('abcdef', 'F')]"
    },
    "endsFalse": {
      "type": "bool",
      "value": "[endsWith('abcdef', 'e')]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
startsTrue	Bool	True
startsCapTrue	Bool	True
startsFalse	Bool	False
endsTrue	Bool	True
endsCapTrue	Bool	True
endsFalse	Bool	False

string

string(valueToConvert)

Convertit la valeur spécifiée en chaîne.

Dans Bicep, utilisez la string fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
valueToConvert	Oui	Quelconque	Valeur à convertir en chaîne. N’importe quel type de valeur peut être converti, y compris les objets et des tableaux.

Valeur retournée

Chaîne de la valeur convertie.

Exemples

L’exemple suivant montre comment convertir différents types de valeurs de chaînes :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
objectOutput	String	{"valueA » :10,"valueB » :"Exemple de texte"}
arrayOutput	String	["a","b","c"]
intOutput	String	5

substring

substring(stringToParse, startIndex, length)

Retourne une sous-chaîne qui commence à la position de caractère spécifiée et qui contient le nombre de caractères spécifié.

Dans Bicep, utilisez la substring fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
chaîne_à_analyser	Oui	string	La chaîne d’origine de laquelle la sous-chaîne est extraite.
index_début	Non	int	La position de caractère (commençant à zéro) de la sous-chaîne.
length	Non	int	Le nombre de caractères de la sous-chaîne. Doit faire référence à un emplacement au sein de la chaîne. Doit être égal à zéro ou supérieur. En cas d’omission, le reste de la chaîne à partir de la position de début sera retourné.

Valeur retournée

Sous-chaîne. Ou une chaîne vide si la longueur est égale à zéro.

Notes

La fonction échoue lorsque la sous-chaîne s’étend au-delà de la fin de la chaîne ou lorsque la longueur est inférieure à zéro. L’exemple suivant échoue avec l’erreur : « Les paramètres d’index et de longueur doivent faire référence à un emplacement dans la chaîne. Paramètre d’index : « 0 », paramètre de longueur : « 11 », longueur du paramètre de chaîne : « 10 ».

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

Exemples

L’exemple suivant extrait une sous-chaîne d’un paramètre :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
substringOutput	String	two

take

take(originalValue, numberToTake)

Retourne un tableau ou une chaîne. Un tableau possède le nombre spécifié d’éléments depuis le début du tableau. Une chaîne possède le nombre de caractères spécifié à partir du début de la chaîne.

Dans Bicep, utilisez la take fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
originalValue	Oui	tableau ou chaîne	Tableau ou chaîne à partir duquel les éléments sont tirés.
numberToTake	Oui	int	Nombre d’éléments ou de caractères à prendre. Si cette valeur est inférieure ou égale à 0, une chaîne ou un tableau vide est renvoyé. Si elle est supérieure à la longueur du tableau ou de la chaîne, tous les éléments du tableau ou de la chaîne sont retournés.

Valeur retournée

Tableau ou chaîne.

Exemples

L’exemple suivant prend le nombre spécifié d’éléments du tableau et des caractères d’une chaîne :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
arrayOutput	Array	["one », « two"]
stringOutput	String	sur

toLower

toLower(stringToChange)

Convertit la chaîne spécifiée en minuscules.

Dans Bicep, utilisez la toLower fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
chaîne_à_modifier	Oui	string	La valeur à convertir en minuscules.

Valeur retournée

Chaîne convertie en minuscules.

Exemples

L’exemple suivant convertit une valeur de paramètre en minuscules et en majuscules :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
toLowerOutput	String	Un deux trois
toUpperOutput	String	UN DEUX TROIS

toUpper

toUpper(stringToChange)

Convertit la chaîne spécifiée en majuscules.

Dans Bicep, utilisez la toUpper fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
chaîne_à_modifier	Oui	string	La valeur à convertir en majuscules.

Valeur retournée

Chaîne convertie en majuscules.

Exemples

L’exemple suivant convertit une valeur de paramètre en minuscules et en majuscules :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
toLowerOutput	String	Un deux trois
toUpperOutput	String	UN DEUX TROIS

trim

trim(stringToTrim)

Supprime tous les espaces de début et de fin de la chaîne indiquée.

Dans Bicep, utilisez la trim fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToTrim	Oui	string	La valeur à supprimer.

Valeur retournée

Chaîne sans les premiers et derniers caractères d’espace.

Exemples

L’exemple suivant supprime les caractères d’espace blanc du paramètre :

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

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
return	String	Un deux trois

uniqueString

uniqueString(baseString, ...)

Crée une chaîne de hachage déterministe basée sur les valeurs fournies en tant que paramètres.

Dans Bicep, utilisez la uniqueString fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
baseString	Oui	string	La valeur utilisée dans la fonction de hachage pour créer une chaîne unique.
paramètres supplémentaires le cas échéant	Non	string	Vous pouvez ajouter autant de chaînes que nécessaire pour créer la valeur qui spécifie le niveau d’unicité.

Notes

Cette fonction est utile lorsque vous avez besoin de créer un nom unique pour une ressource. Vous fournissez des valeurs de paramètre qui limitent l’étendue d’unicité pour le résultat. Vous pouvez spécifier si le nom est unique en abonnement, groupe de ressources ou déploiement.

La valeur retournée n’est pas une chaîne aléatoire, mais plutôt le résultat d’une fonction de hachage. La valeur renvoyée comprend 13 caractères. Elle n’est pas globalement unique. Vous pouvez combiner la valeur avec un préfixe de votre convention d’affectation de noms pour créer un nom explicite. L’exemple suivant montre le format de la valeur renvoyée. La valeur réelle varie en fonction des paramètres fournis.

tcvhiyu5h2o5o

Les exemples suivants montrent comment utiliser uniqueString pour créer une valeur unique pour les niveaux couramment utilisés :

Unique limité à l’abonnement

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

Unique limité au groupe de ressources

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

Unique limité au déploiement pour un groupe de ressources

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

L'exemple suivant montre comment créer un nom unique pour un compte de stockage basé sur votre groupe de ressources. Dans le groupe de ressources, le nom n’est pas unique s’il est construit de la même façon :

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

Si vous devez créer un nom unique chaque fois que vous déployez un modèle et que vous n’avez pas l’intention de mettre à jour la ressource, vous pouvez utiliser la utcNow fonction avec uniqueString. Vous pouvez utiliser cette approche dans un environnement de test. Pour obtenir un exemple, consultez utcNow.

Valeur retournée

Chaîne contenant 13 caractères.

Exemples

Cet exemple retourne des résultats de uniquestring :

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "resources": [],
  "outputs": {
    "uniqueRG": {
      "type": "string",
      "value": "[uniqueString(resourceGroup().id)]"
    },
    "uniqueDeploy": {
      "type": "string",
      "value": "[uniqueString(resourceGroup().id, deployment().name)]"
    }
  }
}

URI

uri(baseUri, relativeUri)

Crée un URI absolu en combinant le baseUri et la chaîne relativeUri.

Dans Bicep, utilisez la uri fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
baseUri	Oui	string	La chaîne d’URI de base. Veillez à observer le comportement concernant la gestion de la barre oblique (`/`) finale, tel qu’il est décrit après ce tableau.
relativeUri	Oui	string	La chaîne d’URI relatif à ajouter à la chaîne d’URI de base.

Si baseUri se termine par une barre oblique de fin, le résultat est simplement baseUri suivi par relativeUri. Si relativeUri elle commence également par une barre oblique de début, la barre oblique de fin et la barre oblique de début sont combinées en une.
S’il baseUri ne se termine pas par une barre oblique de fin, l’une des deux choses se produit.
- S’il baseUri n’y a pas de barres obliques du tout (à part le près de l’avant // ), le résultat est baseUri suivi par relativeUri.
- Si baseUri certaines barres obliques ne se terminent pas par une barre oblique, toutes les barres obliques suivantes sont supprimées baseUri et le résultat est baseUri suivi.relativeUri

Voici quelques exemples :

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

Pour plus d’informations, les paramètres et les paramètres sont résolus, comme spécifié dans la norme RFC 3986, section 5.baseUrirelativeUri

Valeur retournée

Chaîne représentant l’URI absolu pour les valeurs de base et relative.

Exemples

L’exemple suivant montre comment construire un lien vers un modèle imbriqué en fonction de la valeur du modèle parent :

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

L’exemple de modèle suivant montre comment utiliser uri, uriComponentet uriComponentToString:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "uriFormat": "[uri('http://contoso.com/resources/', 'nested/azuredeploy.json')]",
    "uriEncoded": "[uriComponent(variables('uriFormat'))]"
  },
  "resources": [
  ],
  "outputs": {
    "uriOutput": {
      "type": "string",
      "value": "[variables('uriFormat')]"
    },
    "componentOutput": {
      "type": "string",
      "value": "[variables('uriEncoded')]"
    },
    "toStringOutput": {
      "type": "string",
      "value": "[uriComponentToString(variables('uriEncoded'))]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
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)

Encode un URI.

Dans Bicep, utilisez la uriComponent fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
stringToEncode	Oui	string	Valeur à encoder.

Valeur retournée

Chaîne de la valeur encodée de l’URI.

Exemples

L’exemple de modèle suivant montre comment utiliser uri, uriComponentet uriComponentToString:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "uriFormat": "[uri('http://contoso.com/resources/', 'nested/azuredeploy.json')]",
    "uriEncoded": "[uriComponent(variables('uriFormat'))]"
  },
  "resources": [
  ],
  "outputs": {
    "uriOutput": {
      "type": "string",
      "value": "[variables('uriFormat')]"
    },
    "componentOutput": {
      "type": "string",
      "value": "[variables('uriEncoded')]"
    },
    "toStringOutput": {
      "type": "string",
      "value": "[uriComponentToString(variables('uriEncoded'))]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
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)

Retourne une chaîne de la valeur encodée de l’URI.

Dans Bicep, utilisez la uriComponentToString fonction.

Paramètres

Paramètre	Obligatoire	Type	Description
uriEncodedString	Oui	string	Valeur encodée de l’URI à convertir en une chaîne.

Valeur retournée

Chaîne décodée de la valeur encodée de l’URI.

Exemples

L’exemple suivant montre comment utiliser uri, uriComponentet uriComponentToString:

{
  "$schema": "https://schema.management.azure.com/schemas/2019-04-01/deploymentTemplate.json#",
  "contentVersion": "1.0.0.0",
  "variables": {
    "uriFormat": "[uri('http://contoso.com/resources/', 'nested/azuredeploy.json')]",
    "uriEncoded": "[uriComponent(variables('uriFormat'))]"
  },
  "resources": [
  ],
  "outputs": {
    "uriOutput": {
      "type": "string",
      "value": "[variables('uriFormat')]"
    },
    "componentOutput": {
      "type": "string",
      "value": "[variables('uriEncoded')]"
    },
    "toStringOutput": {
      "type": "string",
      "value": "[uriComponentToString(variables('uriEncoded'))]"
    }
  }
}

La sortie des valeurs par défaut de l’exemple précédent est la suivante :

Nom	Type	Valeur
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`

Étapes suivantes

Pour obtenir une description des sections d’un modèle ARM, consultez Comprendre la structure et la syntaxe des modèles ARM.
Pour fusionner plusieurs modèles, consultez Utilisation de modèles liés et imbriqués lors du déploiement de ressources Azure.
Pour itérer un nombre spécifié lors de la création d’un type de ressource, consultez Itération de ressource dans les modèles ARM.
Pour découvrir comment déployer le modèle que vous avez créé, consultez Déployer des ressources avec des modèles ARM et Azure PowerShell.

Rétroaction

Cette page a-t-elle été utile ?

Last updated on 2025-08-13

Partager via

Fonctions de chaîne pour les modèles Resource Manager

base64

Paramètres

Valeur retournée

Exemples

base64ToJson

Paramètres

Valeur retournée

Exemples

base64ToString

Paramètres

Valeur retournée

Exemples

concat

Paramètres

Valeur retournée

Exemples

contains

Paramètres

Valeur retournée

Exemples

dataUri

Paramètres

Valeur retournée

Exemples

dataUriToString

Paramètres

Valeur retournée

Exemples

empty

Paramètres

Valeur retournée

Exemples

endsWith

Paramètres

Valeur retournée

Exemples

first

Paramètres

Valeur retournée

Exemples

format

Paramètres

Notes

Exemples

guid

Paramètres

Notes

Valeur retournée

Exemples

indexOf

Paramètres

Valeur retournée

Exemples

join

Paramètres

Valeur retournée

Exemples

json

last

Paramètres

Valeur retournée

Exemples

lastIndexOf

Paramètres

Valeur retournée

Exemples

length

Paramètres

Valeur retournée

Exemples

newGuid

Notes

Valeur retournée

Exemples

padLeft

Paramètres

Valeur retournée

Exemples