Chaînes de format numériques personnalisées

Vous pouvez créer une chaîne de format numérique personnalisée, qui est composée d'un ou de plusieurs spécificateurs de format numériques personnalisés, pour définir la mise en forme des données numériques. Une chaîne de format numérique personnalisée est une chaîne de format qui n’est pas une chaîne de format numérique standard.

Le tableau suivant décrit les spécificateurs de format numériques personnalisés et affiche un exemple de sortie produite par chaque spécificateur de format. Accédez à la section Notes pour plus d’informations sur l’utilisation de chaînes de format numérique personnalisées et la section Exemple pour obtenir une illustration complète de leur utilisation.

Spécificateur de format	Nom	Descriptif	Exemples
0	Espace réservé du zéro	Remplace le zéro par le chiffre correspondant, le cas échéant ; sinon, le zéro s'affiche dans la chaîne de résultat. Informations supplémentaires : Spécificateur personnalisé « 0 ».	1234.5678 (« 00000 ») -> 01235 0.45678 (« 0.00 », en-US) -> 0.46 0.45678 (« 0.00 », fr-FR) -> 0,46
"#"	Espace réservé de chiffre	Remplace le symbole « # » par le chiffre correspondant, le cas échéant ; sinon, aucun chiffre ne s'affiche dans la chaîne de résultat. Aucun chiffre n’apparaît dans la chaîne de résultat si le chiffre correspondant dans la chaîne d’entrée est un 0 non significatif. Exemple : 0003 ("####") -> 3. Informations supplémentaires : Spécificateur personnalisé « # ».	1234.5678 (« ##### ») -> 1235 0.45678 (« #.## », en-US) -> .46 0.45678 (« #.## », fr-FR) -> ,46
"."	Virgule décimale	Détermine l'emplacement du séparateur décimal dans la chaîne de résultat. Pour plus d’informations : Le spécificateur personnalisé "."	0.45678 (« 0.00 », en-US) -> 0.46 0.45678 (« 0.00 », fr-FR) -> 0,46
","	Séparateur de groupes et mise à l'échelle des nombres	Sert à la fois de séparateur de groupes et de spécificateur de mise à l'échelle des nombres. En tant que séparateur de groupes, il insère un caractère de séparation des groupes localisé entre chaque groupe. En tant que spécificateur de mise à l'échelle des nombres, il divise un nombre par 1000 pour chaque virgule spécifiée. Informations supplémentaires : Spécificateur personnalisé « , ».	Spécificateur de séparateur de groupes : 2147483647 (« ##,# », en-US) -> 2,147,483,647 2147483647 (« #,# », es-ES) -> 2.147.483.647 Spécificateur de mise à l'échelle : 2147483647 (« #,#, », en-US) -> 2 147 2147483647 (« #,#, », es-ES) -> 2.147
«%»	Espace réservé de pourcentage	Multiplie un nombre par 100 et insère un symbole de pourcentage localisé dans la chaîne de résultat. Informations supplémentaires : Spécificateur personnalisé « % ».	0.3697 ( »%#0.00 », en-US) -> %36.97 0.3697 ( »%#0.00 », el-GR) -> %36,97 0.3697 (« ##.0 %« , en-US) -> 37.0 % 0.3697 (« ##.0 %« , el-GR) -> 37,0 %
"‰"	Espace réservé « pour mille »	Multiplie un nombre par 1000 et insère un symbole « pour mille » localisé dans la chaîne de résultat. Informations supplémentaires : Spécificateur personnalisé« ‰ ».	0.03697 (« #0.00> », en-US) -> 36.97> 0.03697 (« #0.00> », ru-RU) -> 36,97>
« E0 » « E+0 » « E-0 » "E0" "E+0" "E-0"	Notation exponentielle	Si le spécificateur est suivi d'au moins un zéro (0), met en forme le résultat à l'aide de la notation exponentielle. La casse de « E » ou « e » indique la casse du symbole d'exposant dans la chaîne de résultat. Le nombre des zéros qui suivent le caractère « E » ou « e » détermine le nombre minimal de chiffres dans l'exposant. Un signe plus (+) indique qu'un caractère de signe précède toujours l'exposant. Un signe moins (-) indique qu'un caractère de signe précède uniquement les exposants négatifs. Informations supplémentaires : Spécificateurs personnalisés « E » et « e ».	987654 (« #0.0e0 ») -> 98.8e4 1503.92311 (« 0.0##e+00 ») -> 1.504e+03 1.8901385E-16 (« 0.0e+00 ») -> 1.9e-16
"\", "''", """"	Caractères d'échappement	Provoque l’interprétation du caractère ou des caractères suivants en tant que littéral plutôt qu’en tant que spécificateur de format personnalisé. Plus d’informations : Caractères d’échappement.	987654 (« \###00\# ») -> #987654# 987654 (« '#'##00'#' ») -> #987654# 987654 (« ""#""##00"""#""" ») -> #987654#
'chaîne' "chaîne"	Délimiteur de chaîne littérale	Indique que les caractères encadrés doivent être copiés inchangés dans la chaîne de résultat. Plus d’informations : Littéraux de caractère.	68 ("# 'degrees'") -> 68 degrés 68 ("#' degrees'") -> 68 degrés
;	Séparateur de section	Définit des sections avec des chaînes de format distinctes pour les nombres positifs, négatifs et nuls. Informations supplémentaires : Séparateur de section « ; ».	12.345 ("#0.0#;( #0.0#) ;-\0-") -> 12.35 0 ("#0.0#;( #0.0#) ;-\0-") -> -0- -12.345 ("#0.0#;( #0.0#) ;-\0-") -> (12.35) 12.345 ("#0.0#;( #0.0#)") -> 12.35 0 ("#0.0#;( #0.0#)") -> 0.0 -12.345 ("#0.0#;( #0.0#)") -> (12.35)
Autres	Tous les autres caractères	Le caractère est copié inchangé dans la chaîne de résultat. Plus d’informations : Littéraux de caractère.	68 ("# °") -> 68 °

Les sections suivantes fournissent des informations détaillées sur chacun des spécificateurs de format numériques personnalisés.

Spécificateur personnalisé « 0 »

Le spécificateur de format personnalisé "0" sert de symbole d'espace réservé du zéro. Si la valeur qui est mise en forme comprend un chiffre à l'emplacement le zéro apparaît dans la chaîne de format, ce chiffre est copié dans la chaîne de résultant ; sinon, un zéro apparaît dans la chaîne de résultat. L'emplacement du zéro situé à l'extrême gauche avant le séparateur décimal et du zéro situé à l'extrême droite après le séparateur décimal détermine la plage des chiffres qui sont toujours présents dans la chaîne de résultat.

Le spécificateur « 00 » provoque l'arrondissement de la valeur au chiffre le plus proche précédant la virgule ; l'arrondissement à une valeur différente de zéro est toujours utilisé. Par exemple, la mise en forme de 34,5 avec « 00 » produit la valeur 35.

L'exemple suivant affiche plusieurs valeurs qui sont mises en forme à l'aide de chaînes de format personnalisées incluant des espaces réservés du zéro.

let
    Source =
    {
        Number.ToText(123, "00000", ""),
        // Displays 00123

        Number.ToText(1.2, "0.00", ""),
        // Displays 1.20

        Number.ToText(1.2, "00.00", ""),
        // Displays 01.20

        Number.ToText(1.2, "00.00", "da-DK"),
        // Displays 01,20

        Number.ToText(.56, "0.0", ""),
        // Displays 0.6

        Number.ToText(1234567890, "0,0", ""),
        // Displays 1,234,567,890

        Number.ToText(1234567890, "0,0", "el-GR"),
        // Displays 1.234.567.890

        Number.ToText(1234567890.123456, "0,0.0", ""),
        // Displays 1,234,567,890.1

        Number.ToText(1234.567890, "0,0.00", "")
        // Displays 1,234.57
    }
in
    Source

Remarque

La valeur de texte vide («  ») dans le dernier paramètre de Number.ToText dans l’exemple précédent fait référence à la culture invariante.

Retour au tableau

Spécificateur personnalisé « # »

Le spécificateur de format personnalisé "#" sert de symbole d'espace réservé des chiffres. Si la valeur qui est mise en forme comprend un chiffre à l'emplacement où le symbole « # » apparaît dans la chaîne de format, ce chiffre est copié dans la chaîne de résultat. Sinon, rien n'est stocké à cet emplacement dans la chaîne résultante.

Notez que ce spécificateur n’affiche jamais un zéro qui n’est pas un chiffre significatif, même si zéro est le seul chiffre de la chaîne. Elle n’affiche zéro que s’il s’agit d’un chiffre significatif dans le nombre affiché.

La chaîne de format « ## » provoque l'arrondissement de la valeur au chiffre le plus proche précédant la virgule ; l'arrondissement à une valeur différente de zéro est toujours utilisé. Par exemple, la mise en forme de 34,5 avec « ## » produit la valeur 35.

L'exemple suivant affiche plusieurs valeurs qui sont mises en forme à l'aide de chaînes de format personnalisées incluant des espaces réservés de chiffres.

let
    Source =
    {
        Number.ToText(1.2, "#.##", ""),
        // Displays 1.2

        Number.ToText(123, "#####"),
        // Displays 123

        Number.ToText(123456, "[##-##-##]"),
        // Displays [12-34-56]

        Number.ToText(1234567890, "#"),
        // Displays 1234567890

        Number.ToText(1234567890, "(###) ###-####")
        // Displays (123) 456-7890
    }
in
    Source

Pour retourner une chaîne de résultat dans laquelle les chiffres absents ou les zéros non significatifs sont remplacés par des espaces, utilisez le Text.PadStart et spécifiez une largeur de champ, comme l’illustre l’exemple suivant.

let
   Source = Text.Format("The value is: '#{0}'", {Text.PadStart(Number.ToText(.324, "#.###"), 5)})
in
   Source

// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'

Retour au tableau

Spécificateur personnalisé « . »

Le spécificateur de format personnalisé "." insère un séparateur décimal localisé dans la chaîne de résultat. Le premier point de la chaîne de format détermine l'emplacement du séparateur décimal dans la valeur mise en forme. Tout autre point est ignoré. Si le spécificateur de format se termine par un « . ». Seuls les chiffres significatifs sont mis en forme dans la chaîne de résultat.

Le caractère utilisé comme séparateur décimal dans la chaîne de résultat n’est pas toujours un point ; elle est déterminée par la culture qui contrôle la mise en forme.

L'exemple suivant utilise le spécificateur de format "." pour définir l'emplacement de la virgule décimale dans plusieurs chaînes de résultat.

let
    Source =
    {
        Number.ToText(1.2, "0.00", ""),
        // Displays 1.20

        Number.ToText(1.2, "00.00", ""),
        // Displays 01.20

        Number.ToText(1.2, "00.00", "da-DK"),
        // Displays 01,20

        Number.ToText(.086, "#0.##%", ""),
        // Displays 8.6%

        Number.ToText(Double.From(86000), "0.###E+0", "")
        // Displays 8.6E+4
    }
in
    Source

Retour au tableau

Spécificateur personnalisé « , »

Le caractère "," sert à la fois de séparateur de groupes et de spécificateur de mise à l'échelle des nombres.

• Séparateur de groupes : si une ou plusieurs virgules sont spécifiées entre deux espaces réservés de chiffres (0 ou #) qui mettent en forme les chiffres intégraux d'un nombre, un caractère de séparation des groupes est inséré entre chaque groupe de nombres dans la partie intégrale de la sortie.

  La culture détermine le caractère utilisé comme séparateur de groupe de nombres et la taille de chaque groupe de nombres. Par exemple, si la chaîne « #,# » et la culture indifférente sont utilisées pour mettre en forme le nombre 1000, la sortie est « 1,000 ».

• Spécificateur de mise à l'échelle des nombres : si une ou plusieurs virgules sont spécifiées immédiatement à gauche du séparateur décimal explicite ou implicite, le nombre à mettre en forme est divisé par 1000 pour chaque virgule. Par exemple, si la chaîne « 0,, » est utilisée pour mettre en forme le nombre 100 millions, la sortie est « 100 ».

Vous pouvez utiliser des spécificateurs de séparateur de groupes et de mise à l'échelle des nombres dans la même chaîne de format. Par exemple, si la chaîne « #,0,, » et la culture indifférente sont utilisées pour mettre en forme le nombre 1 milliard, la sortie est « 1,000 ».

L'exemple suivant illustre l'utilisation de la virgule comme séparateur de groupes.

let
    Source =
    {
        Number.ToText(1234567890, "#,#", ""),
        // Displays 1,234,567,890

        Number.ToText(1234567890, "#,##0,,", "")
        // Displays, 1,235
    }
in
    Source

L'exemple suivant illustre l'utilisation de la virgule comme spécificateur pour la mise à l'échelle des nombres.

let
    Source =
    {
        Number.ToText(1234567890, "#,,", ""),
        // Displays 1235

        Number.ToText(1234567890, "#,,,", ""),
        // Displays 1

        Number.ToText(1234567890, "#,##0,,", "")
        // Displays 1,235
    }
in
    Source

Retour au tableau

Spécificateur personnalisé « % »

Un signe de pourcentage (%) dans une chaîne de format entraîne la multiplication d’un nombre par 100 avant sa mise en forme. Le symbole de pourcentage localisé est inséré dans le nombre à l'emplacement où le caractère % apparaît dans la chaîne de format. Le caractère de pourcentage utilisé est défini par la culture.

L’exemple suivant définit une chaîne de format personnalisée qui inclut le spécificateur personnalisé « % ».

let
    Source = Number.ToText(.086, "#0.##%", "")
    // Displays 8.6%
in
    Source

Retour au tableau

Spécificateur personnalisé « ‰ »

Un caractère par mille (> ou \u2030) dans une chaîne de format entraîne la multiplication d’un nombre par 1000 avant sa mise en forme. Le symbole « pour mille » approprié est inséré dans la chaîne retournée, à l'emplacement où le symbole ‰ apparaît dans la chaîne de format. Le caractère mille utilisé est défini par la culture, qui fournit des informations de mise en forme spécifiques à la culture.

L'exemple suivant définit une chaîne de format personnalisée qui inclut le spécificateur personnalisé "‰".

let
    Source = Number.ToText(.00354, "#0.##" & Character.FromNumber(0x2030), "")
    // Displays 3.54‰
in
    Source

Retour au tableau

Spécificateurs personnalisés « E » et « e »

Si l'une des chaînes "E", "E+", "E-", "e", "e+" ou "e-" est présente dans la chaîne de format et immédiatement suivie d'au moins un zéro, le nombre est mis en forme à l'aide de la notation scientifique, avec un "E" ou un "e" inséré entre le nombre et l'exposant. Le nombre de zéros qui suivent l'indicateur de notation scientifique détermine le nombre minimal de chiffres à afficher pour l'exposant. Les formats "E+" et "e+" indiquent qu'un signe plus ou un signe moins doit toujours précéder l'exposant. Les formats "E", "E-", "e" ou "e-" indiquent qu'un signe ne doit précéder que les exposants négatifs.

L'exemple suivant met en forme plusieurs valeurs numériques à l'aide des spécificateurs pour la notation scientifique.

let
    Source =
    {
        Number.ToText(86000, "0.###E+0", ""),
        // Displays 8.6E+4

        Number.ToText(86000, "0.###E+000", ""),
        // Displays 8.6E+004

        Number.ToText(86000, "0.###E-000", "")
        // Displays 8.6E004
    }
in
    Source

Retour au tableau

Caractères d'échappement

Les symboles "#", "0", ".", ",", "%" et "‰" dans une chaîne de format sont interprétés comme des spécificateurs de format plutôt que comme des caractères littéraux. Selon leur position dans une chaîne de format personnalisée, les majuscules et minuscules « E » ainsi que les symboles + et - peuvent également être interprétés comme spécificateurs de format.

Pour empêcher l’interprétation d’un caractère comme spécificateur de format, vous pouvez :

• Précèdez-le avec une barre oblique inverse.
• Entourez-le d’une citation unique.
• Entourez-le de deux guillemets doubles.

Chacun de ces caractères agit comme des caractères d’échappement. Le caractère d'échappement signifie que le caractère suivant est un caractère littéral qui doit être inclus inchangé dans la chaîne de résultat.

Pour inclure une barre oblique inverse dans une chaîne de résultat, vous devez la placer dans une séquence d'échappement avec une autre barre oblique inverse (\\).

Pour inclure un guillemet unique dans une chaîne de résultat, vous devez l’échapper avec une barre oblique inverse (\'). Si une autre citation unique qui n’est pas échappée précède la citation unique échappée, la barre oblique inverse s’affiche à la place ('\' affiche \).

Pour inclure un guillemet double dans une chaîne de résultat, vous devez échapper deux d’entre eux avec une barre oblique inverse (\"").

L’exemple suivant utilise des caractères d’échappement pour empêcher l’opération de mise en forme d’interpréter les caractères « # », « 0 » et « » comme des caractères d’échappement ou des spécificateurs de format.

let
    Source =
    {
        Number.ToText(123, "\#\#\# ##0 dollars and \0\0 cents \#\#\#"),
        // Displays ### 123 dollars and 00 cents ###

        Number.ToText(123, "'###' ##0 dollars and '00' cents '###'"),
        // Displays ### 123 dollars and 00 cents ###

        Number.ToText(123, """###"" ##0 dollars and ""00"" cents ""###"""),
        // Displays ### 123 dollars and 00 cents ###

        Number.ToText(123, "\\\\\\ ##0 dollars and \0\0 cents \\\\\\"),
        // Displays \\\ 123 dollars and 00 cents \\\

        Number.ToText(123, "'\\\' ##0 dollars and '00' cents '\\\'"),
        // Displays \\\ 123 dollars and 00 cents \\\

        Number.ToText(123, """\\\"" ##0 dollars and ""00"" cents ""\\\""")
        // Displays \\\ 123 dollars and 00 cents \\\
    }
in
    Source

Retour au tableau

Séparateur de section « ; »

Le point-virgule (;) est un spécificateur de format conditionnel qui applique une mise en forme différente à un nombre suivant que sa valeur est positive, négative ou nulle. Pour entraîner ce comportement, une chaîne de format personnalisée peut contenir jusqu'à trois sections séparées par des points-virgules. Ces sections sont décrites dans le tableau suivant.

Nombre de sections	Descriptif
Une section	La chaîne de format s'applique à toutes les valeurs.
Deux sections	La première section s'applique aux valeurs positives et aux zéros, et la deuxième section s'applique aux valeurs négatives. Si le nombre à mettre en forme est négatif, mais devient nul après l'arrondissement au format de la deuxième section, le zéro résultant est mis en forme en fonction de la première section.
Trois sections	La première section s'applique aux valeurs positives, la deuxième section s'applique aux valeurs négatives et la troisième section s'applique aux zéros. La deuxième section peut rester vide (en n'insérant aucune valeur entre les points-virgules), auquel cas la première section s'applique à toutes les valeurs différentes de zéro. Si le nombre à mettre en forme est différent de zéro, mais devient nul après l'arrondissement au format de la première ou deuxième section, le zéro résultant est mis en forme en fonction de la troisième section.

Les séparateurs de section ignorent toute mise en forme préexistante associée à un nombre lorsque la valeur finale est mise en forme. Par exemple, les valeurs négatives sont toujours affichées sans signe moins lorsque des séparateurs de section sont utilisés. Si vous souhaitez que la valeur mise en forme finale soit précédée d'un signe moins, vous devez inclure ce signe explicitement comme élément du spécificateur de format personnalisé.

L'exemple suivant utilise le spécificateur de format ";" pour mettre en forme différemment les nombres positifs, négatifs et nuls.

let
    Source =
    {
        Number.ToText(1234, "##;(##)"),
        // Displays 1234

        Number.ToText(-1234, "##;(##)"),
        // Displays (1234)

        Number.ToText(0, "##;(##);**Zero**")
        // Displays **Zero**
    }
in
    Source

Retour au tableau

Littéraux de caractère

Les spécificateurs de format qui apparaissent dans une chaîne de format numérique personnalisée sont toujours interprétés comme des caractères de mise en forme, jamais comme des caractères littéraux. Il s’agit notamment des caractères suivants :

• 0
• #
• %
• ‰
• '
• \
• ""
• .
• ,
• E ou e, en fonction de sa position dans la chaîne de format.

Tous les autres caractères sont toujours interprétés comme des caractères littéraux et, dans une opération de mise en forme, sont inclus inchangés dans la chaîne de résultat. Dans une opération d’analyse, ils doivent correspondre exactement aux caractères présents dans la chaîne d’entrée. La comparaison respecte la casse.

L’exemple suivant illustre un usage courant des unités de caractères littéraux (dans ce cas, les milliers) :

let
    Source = Number.ToText(123.8, "#,##0.0K")
    // Displays 123.8K
in
    Source

Il existe deux façons d’indiquer que les caractères doivent être interprétés comme des caractères littéraux, et non comme des caractères de mise en forme, pour qu’ils puissent être inclus dans une chaîne de résultat ou analysés correctement dans une chaîne d’entrée :

• En échappant un caractère de mise en forme. Pour plus d’informations, accédez aux caractères d’échappement.

• En plaçant la totalité de la chaîne littérale entre apostrophes.

L’exemple suivant utilise les deux approches pour inclure des caractères réservés dans une chaîne de format numérique personnalisée.

let
    Source =
    {
        Number.ToText(9.3, "##.0\%"),
        // Displays 9.3%

        Number.ToText(9.3, "\'##\'"),
        // Displays '9'

        Number.ToText(9.3, "\\##\\"),
        // Displays \9\

        Number.ToText(9.3, "##.0'%'"),
        // Displays 9.3%

        Number.ToText(9.3, "'\'##'\'"),
        // Displays \9\

        Number.ToText(9.3, "##.0""%"""),
        // Displays 9.3%

        Number.ToText(9.3, "\""##\""")
        // Displays "9"
    }
in
    Source

Remarques

Infinis à virgule flottante et NaN

Quelle que soit la chaîne de format, si la valeur d’un Decimal.Type, Single.Type ou Double.Type type à virgule flottante est l’infini positif, l’infini négatif ou non un nombre (NaN), la chaîne mise en forme est la valeur de la Number.PositiveInfinity, Number.NegativeInfinityou des constantes Number.NaN spécifiées par la culture actuellement applicable.

Arrondi et chaînes de format à virgule fixe

Pour les chaînes de format à virgule fixe (c’est-à-dire, les chaînes de format de mise en forme scientifique), les nombres sont arrondis à autant de décimales qu’il y a des espaces réservés numériques à droite de la virgule décimale. Si la chaîne de format ne contient pas de virgule décimale, le nombre est arrondi à l’entier le plus proche. Si le nombre possède plus de chiffres que d'espaces réservés de chiffres à gauche de la virgule décimale, les chiffres supplémentaires sont copiés dans la chaîne résultante immédiatement avant le premier espace réservé de chiffre.

Retour au tableau

Exemple

L'exemple suivant présente deux chaînes de format numériques personnalisées. Dans les deux cas, l'espace réservé de chiffre (#) affiche les données numériques, et tous les autres caractères sont copiés dans la chaîne de résultat.

let
    Source =
    {
        Number.ToText(1234567890, "(###) ###-####"),
        // Displays (123) 456-7890

        Number.ToText(42, "My Number = #")
        // Displays My number = 42
    }
in
    Source

Retour au tableau

Contenu connexe

• Comment la culture affecte la mise en forme du texte
• Conversion de type de nombre
• Types de données dans Power Query
• Chaînes de format numériques standard