Chaînes de format numériques standard

2025-06-10

Les chaînes de format numériques standard sont utilisées pour mettre en forme des types numériques courants. Une chaîne de format numérique standard se présente sous la forme [format specifier][precision specifier], où :

Le spécificateur de format est un caractère alphabétique unique qui spécifie le type de format de nombre, par exemple devise ou pourcentage. Toute chaîne de format numérique contenant plusieurs caractères alphabétiques, y compris un espace blanc, est interprétée comme une chaîne de format numérique personnalisée. Pour plus d’informations, accédez aux chaînes de format numérique personnalisées.
Le spécificateur de précision est un entier facultatif qui affecte le nombre de chiffres dans la chaîne obtenue. Le spécificateur de précision contrôle le nombre de chiffres dans la représentation sous forme de chaîne d'un nombre.

Lorsque le spécificateur de précision contrôle le nombre de chiffres fractionnels dans la chaîne de résultat, la chaîne de résultat reflète un nombre arrondi à un résultat représentant le plus proche du résultat infiniment précis.

Remarque

Le spécificateur de précision détermine le nombre de chiffres dans la chaîne de résultat. Pour remplir une chaîne de résultat avec des espaces de début ou de fin ou d’autres caractères (par exemple, 0), utilisez les fonctions Text.PadStart et Text.PadEnd et utilisez la longueur globale count dans ces fonctions pour remplir la chaîne de résultat.

Les chaînes de format numérique standard sont prises en charge par la fonction Number.ToText.

Spécificateurs de format standard

Le tableau suivant décrit les spécificateurs de format numériques standard et affiche une 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 standard et la section Exemple de code pour obtenir une illustration complète de leur utilisation.

Remarque

Le résultat d’une chaîne mise en forme d’une culture spécifique peut différer des exemples suivants. Les paramètres du système d’exploitation, les paramètres utilisateur, les variables d’environnement et d’autres paramètres sur le système que vous utilisez peuvent tous affecter le format.

Spécificateur de format	Nom	Descriptif	Exemples
"C" ou "c"	Devise	Résultat : une valeur monétaire. Pris en charge par : tous les types numériques. Spécificateur de précision : nombre de chiffres décimaux. Spécificateur de précision par défaut : défini par la culture. Informations supplémentaires : Spécificateur de format monétaire ("C").	123.456 (« C », en-US) -> 123,46 $ 123.456 (« C », fr-FR) -> 123 46 € 123.456 (« C », ja-JP) - -123.456 (« C3 », en-US) -> (123 456,00 $) -123.456 (« C3 », fr-FR) -> -123,456 € -123.456 (« C3 », ja-JP) -> ->123.456
"D" ou "d"	Décimal	Résultat : chiffres entiers avec un signe négatif facultatif. Pris en charge par : les types intégraux uniquement. Spécificateur de précision : nombre minimal de chiffres. Spécificateur de précision par défaut : nombre minimal de chiffres requis. Informations supplémentaires : Spécificateur de format décimal ("D").	1234 (« D ») -> 1234 -1234 (« D6 ») -> -001234
"E" ou "e"	Exponentiel (scientifique)	Résultat : notation exponentielle. Pris en charge par : tous les types numériques. Spécificateur de précision : nombre de chiffres décimaux. Spécificateur de précision par défaut : 6. Informations supplémentaires : Spécificateur de format exponentiel ("E").	1052.0329112756 (« E », en-US) -> 1.052033E+003 1052.0329112756 (« e », fr-FR) -> 1 052033e+003 -1052.0329112756 (« e2 », en-US) -> -1.05e+003 -1052.0329112756 (« E2 », fr-FR) -> -1 05E+003
"F" ou "f"	Virgule fixe	Résultat : chiffres intégraux et décimaux avec un signe négatif facultatif. Pris en charge par : tous les types numériques. Spécificateur de précision : nombre de chiffres décimaux. Spécificateur de précision par défaut : défini par la culture. Informations supplémentaires : Spécificateur de format à virgule fixe ("F").	1234.567 (« F », en-US) -> 1234.57 1234.567 (« F », de-DE) -> 1234 57 1234 (« F1 », en-US) -> 1234.0 1234 (« F1 », de-DE) -> 1234,0 -1234.56 (« F4 », en-US) -> -1234.5600 -1234.56 (« F4 », de-DE) -> -1234 5600
"G" ou "g"	Général	Résultat : format le plus compact (notation à virgule fixe ou scientifique). Pris en charge par : tous les types numériques. Spécificateur de précision : nombre de chiffres significatifs. Spécificateur de précision par défaut : dépend du type numérique. Informations supplémentaires : Spécificateur de format standard ("G").	-123.456 (« G », en-US) -> -123.456 -123.456 (« G », sv-SE) -> -123 456 123.4546 (« G4 », en-US) -> 123.5 123.4546 (« G4 », sv-SE) -> 123,5 -1.234567890e-25 (« G », en-US) -> -1.23456789E-25 -1.234567890e-25 (« G », sv-SE) -> -1 23456789E-25
"N" ou "n"	Numéro	Résultat : chiffres intégraux et décimaux, séparateurs de groupes et séparateur décimal avec un signe négatif facultatif. Pris en charge par : tous les types numériques. Spécificateur de précision : nombre souhaité de décimales. Spécificateur de précision par défaut : défini par la culture. Informations supplémentaires : Spécificateur de format numérique ("N").	1234.567 (« N », en-US) -> 1 234,57 1234.567 (« N », ru-RU) -> 1 234 57 1234 (« N1 », en-US) -> 1 234.0 1234 (« N1 », ru-RU) -> 1 234 00 -1234.56 (« N3 », en-US) -> -1 234.560 -1234.56 (« N3 », ru-RU) -> -1 234 560
"P" ou "p"	Pourcentage	Résultat : nombre multiplié par 100 et affiché avec un symbole de pourcentage. Pris en charge par : tous les types numériques. Spécificateur de précision : nombre souhaité de décimales. Spécificateur de précision par défaut : défini par la culture. Informations supplémentaires : Spécificateur de format pourcentage ("P").	1 (« P », en-US) -> 100,00 % 1 (« P », fr-FR) -> 100,00 % -0.39678 (« P1 », en-US) -> -39.7 % -0.39678 (« P1 », fr-FR) -> -39,7 %
"X" ou "x"	Valeur hexadécimale	Résultat : chaîne hexadécimale. Pris en charge par : les types intégraux uniquement. Spécificateur de précision : nombre de chiffres dans la chaîne de résultat. Informations supplémentaires : Spécificateur de format hexadécimal ("X").	255 (« X ») -> FF -1 (« x ») -> ff 255 (« x4 ») -> 00ff -1 (« X4 ») -> 00FF
N'importe quel caractère	Spécificateur inconnu	Résultat : lève une erreur d’expression au moment de l’exécution.

Utiliser des chaînes de format numériques standard

Une chaîne de format numérique standard peut être utilisée pour définir la mise en forme d’une valeur numérique. Il peut être passé au paramètre Number.ToTextformat. L'exemple suivant met en forme une valeur numérique en tant que chaîne monétaire dans la culture actuelle (dans le cas présent, la culture en-US).

Number.ToText(123.456, "C2")
// Displays $123.46

Si vous le souhaitez, vous pouvez fournir un argument count dans les fonctions Text.PadStart et Text.PadEnd pour spécifier la largeur du champ numérique et indiquer si sa valeur est alignée à droite ou à gauche. Par exemple, l’exemple suivant aligne une valeur monétaire dans un champ de 28 caractères et aligne à droite une valeur monétaire dans un champ de 14 caractères (lors de l’utilisation d’une police monospaceée).

let
    amounts = {16305.32, 18794.16},
    result = Text.Format("    Beginning Balance           Ending Balance#(cr,lf)    #{0}#{1}",
    {
        Text.PadEnd(Number.ToText(amounts{0}, "C2"), 28), 
        Text.PadStart(Number.ToText(amounts{1}, "C2"), 14)
    })
in
    result

// Displays:
//    Beginning Balance           Ending Balance
//    $16,305.32                      $18,794.16

Les sections suivantes fournissent des informations détaillées sur chacune des chaînes de format numériques standard.

Spécificateur de format monétaire (C)

Le spécificateur de format "C" (ou monétaire) convertit un nombre en une chaîne qui représente un montant en devise. Le spécificateur de précision indique le nombre souhaité de décimales dans la chaîne de résultat. Si le spécificateur de précision est omis, le nombre par défaut de décimales à utiliser dans les valeurs monétaires est 2.

Si la valeur à mettre en forme contient un nombre de décimales supérieur au nombre spécifié ou au nombre par défaut, la valeur fractionnaire est arrondie dans la chaîne de résultat. Si la valeur à droite du nombre de décimales est égale à 5 ou supérieure, le dernier chiffre dans la chaîne de résultat est arrondi à une valeur différente de zéro.

La chaîne de résultat est affectée par les informations de mise en forme de la culture actuelle.

L’exemple suivant met en forme une valeur avec le spécificateur de format monétaire :

let
    Source = 
    {
        Number.ToText(12345.6789, "C"),
        Number.ToText(12345.6789, "C3"),
        Number.ToText(12345.6789, "C3", "da-DK")
    }
in
    Source 

// The example displays the following list on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr.

Spécificateur de format décimal (D)

Le spécificateur de format "D" (ou décimal) convertit un nombre en une chaîne de chiffres décimaux (0-9), préfixée par un signe moins si le nombre est négatif. Ce format est pris en charge par les types intégraux uniquement.

Le spécificateur de précision indique le nombre minimal de chiffres voulu dans la chaîne résultante. Le cas échéant, des zéros sont ajoutés à la gauche du nombre afin de fournir le nombre de chiffres déterminé par le spécificateur de précision. Si aucun spécificateur de précision n'est spécifié, la valeur par défaut est la valeur minimale requise pour représenter l'entier sans zéros non significatifs.

La chaîne de résultat est affectée par les informations de mise en forme de la culture actuelle.

L’exemple suivant met en forme une valeur avec le spécificateur de format décimal.

let
    Source = 
    { 
        Number.ToText(12345, "D"),
        // Displays 12345

        Number.ToText(12345, "D8"),
        // Displays 00012345

        Number.ToText(-12345, "D"),
        // Displays -12345

        Number.ToText(-12345, "D8")
        // Displays -00012345
    }
in
    Source

Spécificateur de format exponentiel (D)

Le spécificateur de format exponentiel ("E") convertit un nombre en une chaîne au format "-d.ddd…E+ddd" ou "-d.ddd…e+ddd", où chaque "d" correspond à un chiffre (0-9). La chaîne commence par un signe moins si le nombre est négatif. Un chiffre exactement précède toujours la virgule décimale.

Le spécificateur de précision indique le nombre de chiffres voulu après la virgule décimale. Si vous avez omis le spécificateur de précision, une précision par défaut de six chiffres après la virgule décimale est utilisée.

La casse du spécificateur de format indique si le préfixe "E" ou "e" doit être ajouté à l'exposant. L'exposant est toujours constitué d'un signe plus ou moins et d'un minimum de trois chiffres. Le cas échéant, des zéros sont ajoutés à l'exposant pour respecter ce minimum.

La chaîne de résultat est affectée par les informations de mise en forme de la culture actuelle.

L’exemple suivant met en forme une valeur avec le spécificateur de format exponentiel :

let
    Source = 
    { 
        Number.ToText(12345.6789, "E", ""),
        // Displays 1.234568E+004

        Number.ToText(12345.6789, "E10", ""),
        // Displays 1.2345678900E+004

        Number.ToText(12345.6789, "e4", ""),
        // 1.2346e+004

        Number.ToText(12345.6789, "E", "fr-FR")
        // Displays 1,234568E+004
    }
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.

Spécificateur de format à virgule fixe (F)

Le spécificateur de format à virgule fixe ("F") convertit un nombre en chaîne au format "-ddd.ddd…" où chaque "d" correspond à un chiffre (0-9). La chaîne commence par un signe moins si le nombre est négatif.

Le spécificateur de précision indique le nombre de décimales voulu. Si le spécificateur de précision est omis, le nombre par défaut de décimales à utiliser dans les valeurs numériques est 2.

La chaîne de résultat est affectée par les informations de mise en forme de la culture actuelle.

L’exemple suivant met en forme un double et une valeur entière avec le spécificateur de format de point fixe :

let
    Source =
    {
        Number.ToText(17843, "F", ""),
        // Displays 17843.00

        Number.ToText(-29541, "F3", ""),
        // Displays -29541.000

        Number.ToText(18934.1879, "F", ""),
        // Displays 18934.19

        Number.ToText(18934.1879, "F0", ""),
        // Displays 18934

        Number.ToText(-1898300.1987, "F1", ""),
        // Displays -1898300.2

        Number.ToText(-1898300.1987, "F3", "es-ES")
        // Displays -1898300,199
    }
in
    Source

Spécificateur de format général (G)

Le spécificateur de format général (« G ») convertit un nombre dans le format le plus compact (notation à virgule fixe ou notation scientifique), en fonction du type du nombre et de la présence d'un spécificateur de précision. Le spécificateur de précision définit le nombre maximal des chiffres significatifs qui peuvent s'afficher dans la chaîne de résultat. Si le spécificateur de précision est omis ou est égal à zéro, le type du nombre détermine la précision par défaut, comme indiqué dans le tableau suivant.

Type numérique	Précision par défaut
`Byte.Type` ou `Int8.Type`	3 chiffres
`Int16.Type`	5 chiffres
`Int32.Type`	10 chiffres
`Int64.Type`	19 chiffres
`Single.Type`	9 chiffres
`Double.Type`	17 chiffres
`Decimal.Type`	15 chiffres

La notation à virgule fixe est utilisée si l'exposant résultant de l'expression du nombre en notation scientifique est supérieur à -5 et inférieur au spécificateur de précision ; dans le cas contraire, la notation scientifique est utilisée. Le résultat contient un séparateur décimal si nécessaire et les zéros non significatifs situés après le séparateur décimal sont omis. Si le spécificateur de précision est présent et que le nombre de chiffres significatifs dans le résultat est supérieur à la précision indiquée, les chiffres de fin en trop sont supprimés par arrondi.

Toutefois, si le nombre est un Decimal.Type et que le spécificateur de précision est omis, la notation à virgule fixe est toujours utilisée et les zéros de fin sont conservés.

Si la notation scientifique est utilisée, l'exposant du résultat est précédé de "E" si le spécificateur de format est "G", ou de "e" si le spécificateur de format est "g". L'exposant contient au minimum deux chiffres. Cela diffère du format utilisé pour la notation scientifique produite par le spécificateur de format exponentiel, lequel inclut un minimum de trois chiffres dans l'exposant.

La chaîne de résultat est affectée par les informations de mise en forme de la culture actuelle.

L’exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format général :

let
    Source =
    {
        Number.ToText(12345.6789, "G", ""),
        // Displays 12345.6789

        Number.ToText(12345.6789, "G", "fr-FR"),
        // Displays 12345,6789

        Number.ToText(12345.6789, "G7", ""),
        // Displays 12345.68

        Number.ToText(.0000023, "G", ""),
        // Displays 2.3E-06

        Number.ToText(.0000023, "G", "fr-FR"),
        // Displays 2,3E-06

        Number.ToText(.0023, "G", ""),
        // Displays 0.0023

        Number.ToText(1234, "G2", ""),
        // Displays 1.2E+03

        Number.ToText(Number.PI, "G5", "")
        // Displays 3.1416
    }
in
    Source

Spécificateur de format numérique (N)

Le spécificateur de format numérique ("N") convertit un nombre en une chaîne au format "-d,ddd,ddd.ddd…", où "-" correspond, le cas échéant, à un symbole de nombre négatif, "d" indique un chiffre (0-9), "," indique un séparateur de groupes et "." correspond à une virgule décimale. Le spécificateur de précision indique le nombre de chiffres voulu après la virgule décimale. Si le spécificateur de précision est omis, le nombre de décimales est défini par la culture actuelle.

La chaîne de résultat est affectée par les informations de mise en forme de la culture actuelle.

L’exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format de nombre :

let
    Source =
    {
        Number.ToText(-12445.6789, "N", ""),
        // Displays -12,445.68

        Number.ToText(-12445.6789, "N1", "sv-SE"),
        // Displays -12 445,7

        Number.ToText(123456789, "N1", "")
        // Displays 123,456,789.0
    }
in
    Source

Spécificateur de format de pourcentage (P)

Le spécificateur de format pourcentage ("P") multiplie un nombre par 100 et le convertit en une chaîne qui représente un pourcentage. Le spécificateur de précision indique le nombre de décimales voulu. Si le spécificateur de précision est omis, la précision numérique par défaut fournie par la culture actuelle est utilisée.

L’exemple suivant met en forme des valeurs à virgule flottante assorties avec le spécificateur de format pourcentage :

let
    Source =
    {
        Number.ToText(.2468013, "P", ""),
        // Displays 24.68 %

        Number.ToText(.2468013, "P", "hr-HR"),
        // Displays 24,68 %

        Number.ToText(.2468013, "P1", "en-US")
        // Displays 24.7%
    }
in
    Source

Spécificateur de format hexadécimal (X)

Le spécificateur de format hexadécimal ("X") convertit un nombre en une chaîne de chiffres hexadécimaux. La casse du spécificateur de format indique s'il convient d'utiliser des caractères majuscules ou minuscules pour les chiffres hexadécimaux supérieurs à 9. Par exemple, utilisez "X" pour produire "ABCDEF" et "x" pour produire "abcdef". Ce format est pris en charge par les types intégraux uniquement.

La chaîne de résultat n’est pas affectée par les informations de mise en forme de la culture actuelle.

L'exemple suivant met en forme des valeurs avec le spécificateur de format hexadécimal.

let
    Source =
    {
        Number.ToText(0x2045e, "x"),
        // Displays 2045e

        Number.ToText(0x2045e, "X"),
        // Displays 2045E

        Number.ToText(0x2045e, "X8"),
        // Displays 0002045E

        Number.ToText(123456789, "X"),
        // Displays 75BCD15

        Number.ToText(123456789, "X2")
        // Displays 75BCD15
    }
in
    Source

Remarques

Cette section contient des informations supplémentaires sur l’utilisation de chaînes de format numériques standard.

Types numériques intégraux et à virgule flottante

Certaines descriptions de spécificateurs de format numériques standard font référence à des types numériques intégraux ou à virgule flottante. Les types numériques intégraux sont Byte.Type, , Int8.TypeInt16.Type, Int32.TypeetInt64.Type. Les types numériques à virgule flottante sont Decimal.Type, Single.Type et Double.Type.

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.

Exemple de code

L’exemple suivant met en forme un point flottant et une valeur numérique intégrale à l’aide de la culture en-US et de tous les spécificateurs de format numérique standard. Cet exemple utilise deux types numériques particuliers (Double.Type et Int32.Type), mais génère des résultats similaires pour l’un des autres types de base numériques (Byte.Type, , Decimal.Type, Int8.TypeInt16.Type, Int64.Typeet Single.Type).

let
    // Display text representations of numbers for en-US culture
    culture = "en-US",

    // Output floating point values
    floating = Double.From(10761.937554),
    #"Floating results" = 
    {
        Text.Format("C: #{0}", {Number.ToText(floating, "C", culture)}),         // Displays "C: $10,761.94"
        Text.Format("E: #{0}", {Number.ToText(floating, "E03", culture)}),       // Displays "E: 1.076E+004"
        Text.Format("F: #{0}", {Number.ToText(floating, "F04", culture)}),       // Displays "F: 10761.9376"
        Text.Format("G: #{0}", {Number.ToText(floating, "G", culture)}),         // Displays "G: 10761.937554"
        Text.Format("N: #{0}", {Number.ToText(floating, "N03", culture)}),       // Displays "N: 10,761.938"
        Text.Format("P: #{0}", {Number.ToText(floating/10000, "P02", culture)})  // Displays "P: 107.62%"
    },
    
    // Output integral values
    integral = Int32.From(8395),
    #"Integral results" =
    {
        Text.Format("C: #{0}", {Number.ToText(integral, "C", culture)}),         // Displays "C: $8,395.00"
        Text.Format("D: #{0}", {Number.ToText(integral, "D6", culture)}),        // Displays "D: 008395"
        Text.Format("E: #{0}", {Number.ToText(integral, "E03", culture)}),       // Displays "E: 8.395E+003"
        Text.Format("F: #{0}", {Number.ToText(integral, "F01", culture)}),       // Displays "F: 8395.0"
        Text.Format("G: #{0}", {Number.ToText(integral, "G", culture)}),         // Displays "G: 8395"
        Text.Format("N: #{0}", {Number.ToText(integral, "N01", culture)}),       // Displays "N: 8,395.0"
        Text.Format("P: #{0}", {Number.ToText(integral/10000, "P02", culture)}), // Displays "P: 83.95%"
        Text.Format("X: 0x#{0}", {Number.ToText(integral, "X", culture)})        // Displays "X: 0x20CB"
    },
    results = #"Floating results" & #"Integral results"

in
    results

Partager via

Chaînes de format numériques standard

Spécificateurs de format standard

Utiliser des chaînes de format numériques standard

Spécificateur de format monétaire (C)

Spécificateur de format décimal (D)

Spécificateur de format exponentiel (D)

Spécificateur de format à virgule fixe (F)

Spécificateur de format général (G)

Spécificateur de format numérique (N)

Spécificateur de format de pourcentage (P)

Spécificateur de format hexadécimal (X)

Remarques

Types numériques intégraux et à virgule flottante

Infinis à virgule flottante et NaN

Exemple de code

Contenu connexe

Commentaires

Ressources supplémentaires