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

Nous recommandons Bicep parce qu’il offre les mêmes fonctionnalités que les modèles ARM et que la syntaxe est plus facile d’utilisation. 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 fonction base64.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	one, two, three
toJsonOutput	Object	{"one": "a", "two": "b"}

base64ToJson

base64ToJson(base64Value)

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

Dans Bicep, utilisez la fonction base64ToJson.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	one, two, three
toJsonOutput	Object	{"one": "a", "two": "b"}

base64ToString

base64ToString(base64Value)

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

Dans Bicep, utilisez la fonction base64ToString.

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

La sortie de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
base64Output	String	b25lLCB0d28sIHRocmVl
toStringOutput	String	one, two, three
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înes dans des chaînes multilignes, vous devez peut-être revenir à l’utilisation de la fonction concat() ou de la fonction replace().

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 à la fois 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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, un objet contient une clé ou 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 fonction contains.

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction dataUri.

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 un URI de données et convertit 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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

dataUriToString

dataUriToString(dataUriToConvert)

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

Dans Bicep, utilisez la fonction dataUriToString.

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 un URI de données et convertit 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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

empty

empty(itemToTest)

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

Dans Bicep, utilisez la fonction empty.

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction endsWith.

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 ou les derniers 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction first.

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 type (chaîne, entier, tableau ou objet) du premier élément d’un tableau.

Exemples

L’exemple suivant montre comment utiliser la première 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction format.

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 fonction format.

{
  "$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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction guid.

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 pour l’abonnement, le groupe de ressources ou le 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 autre GUID non basé sur cette valeur de hachage des paramètres, utilisez la fonction newGuid.

Les exemples suivants montrent comment utiliser guid pour créer une valeur unique pour des 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.

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 fonction indexOf.

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction join.

Paramètres

Paramètre	Obligatoire	Type	Description
inputArray	Yes	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 à des chaînes délimitées au moyen de 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 la fonction json.

Dans Bicep, utilisez la fonction json.

last

last(arg1)

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

Dans Bicep, utilisez la fonction last.

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 indique comment utiliser la fonction last 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction lastIndexOf.

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction length.

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 indique comment utiliser la fonction length 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction newGuid.

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 fonction guid, 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 choisissez l’option de redéployer un déploiement précédent réussi et que ce déploiement inclut un paramètre qui utilise newGuid, le paramètre n’est pas réévalué. Au lieu de cela, la valeur du paramètre du déploiement précédent est automatiquement réutilisée dans le déploiement de la restauration.

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 avec uniqueString pour créer des noms uniques.

Soyez prudent quand vous redéployez un modèle basé sur la fonction newGuid 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 convenir dans un environnement de test où le compte de stockage est utilisé pendant une courte période et n’est pas redéployé.

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

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 fonction padLeft.

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 ci-après indique comment remplir la valeur de paramètre fournie par l’utilisateur avec le caractère zéro jusqu’à atteindre le nombre total de caractères.

{
  "$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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction replace.

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 illustre comment supprimer tous les tirets de la chaîne fournie par l’utilisateur et comment remplacer une partie de la chaîne par une autre chaîne.

{
  "$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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction skip.

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
arrayOutput	Array	["three"]
stringOutput	String	two three

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 fonction split.

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 par une virgule et par 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction startsWith.

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 ou les premiers 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction string.

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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
objectOutput	String	{"valueA":10,"valueB":"Example Text"}
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 fonction substring.

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 correspondre à un emplacement au sein de la chaîne. Le paramètre d'index : '0', le paramètre de longueur : '11', le paramètre de longueur de la 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 à partir 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction take.

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 les 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction toLower.

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 ci-après 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
toLowerOutput	String	one two three
toUpperOutput	String	ONE TWO THREE

toUpper

toUpper(stringToChange)

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

Dans Bicep, utilisez la fonction toUpper.

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 ci-après 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
toLowerOutput	String	one two three
toUpperOutput	String	ONE TWO THREE

trim

trim(stringToTrim)

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

Dans Bicep, utilisez la fonction trim.

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 espaces à partir 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

Nom	Type	Valeur
return	String	one two three

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 fonction uniqueString.

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 pour l’abonnement, le groupe de ressources ou le déploiement.

La valeur retournée n’est pas une chaîne aléatoire, mais le résultat d’une fonction de hachage. La valeur renvoyée comprend 13 caractères. Elle n’est pas globalement unique. Il se peut que vous souhaitiez associer un préfixe de votre convention d’affectation de noms à la valeur 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 des 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’envisagez pas de mettre à jour la ressource, utilisez la fonction utcNow 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 fonction uri.

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 finale, le résultat est baseUri suivi de relativeUri.

• Si baseUri ne se termine pas par une barre oblique finale, deux événements sont possibles.

  • Si baseUri n’a aucune barre oblique (hormis // près du début), le résultat est baseUri suivi de relativeUri.

  • Si baseUri comporte des barres obliques, mais ne se termine pas par une barre oblique, tout ce qui se trouve après la dernière barre oblique est supprimé de baseUri et le résultat est baseUri suivi de 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/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 obtenir des détails complets, les paramètres baseUri et relativeUri sont résolus comme indiqué dans la RFC 3986, section 5.

Valeur retournée

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

Exemples

L’exemple suivant montre comment créer 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 la fonction uri, uriComponent et 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction uriComponent.

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 la fonction uri, uriComponent et 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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 fonction uriComponentToString.

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, uriComponent et 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 de l’exemple précédent avec les valeurs par défaut se présente comme suit :

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.