Partage via


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) :

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 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 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 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 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 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 relativeUri les baseUri paramètres sont résolus comme spécifié dans 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