Procédure : remplir un nombre avec des zéros non significatifsHow to: Pad a Number with Leading Zeros

Vous pouvez ajouter des zéros non significatifs à un entier en utilisant la chaîne de format numérique standard « D » avec un spécificateur de précision.You can add leading zeros to an integer by using the "D" standard numeric format string with a precision specifier. Vous pouvez ajouter des zéros non significatifs aux nombres entiers et à virgule flottante en utilisant une chaîne de format numérique personnalisée.You can add leading zeros to both integer and floating-point numbers by using a custom numeric format string. Cet article montre comment utiliser les deux méthodes pour remplir un nombre avec des zéros non significatifs.This article shows how to use both methods to pad a number with leading zeros.

Pour remplir un entier avec des zéros non significatifs dans la limite d'une longueur spécifiqueTo pad an integer with leading zeros to a specific length

  1. Déterminez le nombre minimal de chiffres que la valeur entière doit afficher.Determine the minimum number of digits you want the integer value to display. Incluez des chiffres non significatifs dans ce nombre.Include any leading digits in this number.

  2. Déterminez si vous souhaitez afficher l'entier en tant que valeur décimale ou que valeur hexadécimale.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Pour afficher l’entier comme valeur décimale, appelez sa méthode ToString(String), puis passez la chaîne « Dn » comme valeur du paramètre format, où n représente la longueur minimale de la chaîne.To display the integer as a decimal value, call its ToString(String) method, and pass the string "Dn" as the value of the format parameter, where n represents the minimum length of the string.

    • Pour afficher l’entier comme valeur hexadécimale, appelez sa méthode ToString(String), puis transmettez la chaîne « Xn » comme valeur du paramètre de format, où n représente la longueur minimale de la chaîne.To display the integer as a hexadecimal value, call its ToString(String) method and pass the string "Xn" as the value of the format parameter, where n represents the minimum length of the string.

Vous pouvez également utiliser la chaîne de format dans une chaîne interpolée dans C# et Visual Basic, ou vous pouvez appeler une méthode, telle que String.Format ou Console.WriteLine, qui utilise la mise en forme composite.You can also use the format string in an interpolated string in both C# and Visual Basic, or you can call a method, such as String.Format or Console.WriteLine, that uses composite formatting.

L'exemple suivant met en forme plusieurs valeurs entières avec des zéros non significatifs de manière à ce que la longueur totale du nombre mis en forme soit au moins égale à huit caractères.The following example formats several integer values with leading zeros so that the total length of the formatted number is at least eight characters.

byte byteValue = 254;
short shortValue = 10342;
int intValue = 1023983;
long lngValue = 6985321;
ulong ulngValue = UInt64.MaxValue;

// Display integer values by calling the ToString method.
Console.WriteLine("{0,22} {1,22}", byteValue.ToString("D8"), byteValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", shortValue.ToString("D8"), shortValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", intValue.ToString("D8"), intValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", lngValue.ToString("D8"), lngValue.ToString("X8"));
Console.WriteLine("{0,22} {1,22}", ulngValue.ToString("D8"), ulngValue.ToString("X8"));
Console.WriteLine();

// Display the same integer values by using composite formatting.
Console.WriteLine("{0,22:D8} {0,22:X8}", byteValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", shortValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", intValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", lngValue);
Console.WriteLine("{0,22:D8} {0,22:X8}", ulngValue);
// The example displays the following output:
//                     00000254               000000FE
//                     00010342               00002866
//                     01023983               000F9FEF
//                     06985321               006A9669
//         18446744073709551615       FFFFFFFFFFFFFFFF
//
//                     00000254               000000FE
//                     00010342               00002866
//                     01023983               000F9FEF
//                     06985321               006A9669
//         18446744073709551615       FFFFFFFFFFFFFFFF
//         18446744073709551615       FFFFFFFFFFFFFFFF
Dim byteValue As Byte = 254
Dim shortValue As Short = 10342
Dim intValue As Integer = 1023983
Dim lngValue As Long = 6985321
Dim ulngValue As ULong = UInt64.MaxValue

' Display integer values by calling the ToString method.
Console.WriteLine("{0,22} {1,22}", byteValue.ToString("D8"), byteValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", shortValue.ToString("D8"), shortValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", intValue.ToString("D8"), intValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", lngValue.ToString("D8"), lngValue.ToString("X8"))
Console.WriteLine("{0,22} {1,22}", ulngValue.ToString("D8"), ulngValue.ToString("X8"))
Console.WriteLine()

' Display the same integer values by using composite formatting.
Console.WriteLine("{0,22:D8} {0,22:X8}", byteValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", shortValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", intValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", lngValue)
Console.WriteLine("{0,22:D8} {0,22:X8}", ulngValue)
' The example displays the following output:
'                     00000254               000000FE
'                     00010342               00002866
'                     01023983               000F9FEF
'                     06985321               006A9669
'         18446744073709551615       FFFFFFFFFFFFFFFF
'       
'                     00000254               000000FE
'                     00010342               00002866
'                     01023983               000F9FEF
'                     06985321               006A9669
'         18446744073709551615       FFFFFFFFFFFFFFFF

Pour remplir un entier avec un nombre spécifique de zéros non significatifsTo pad an integer with a specific number of leading zeros

  1. Déterminez le nombre de zéros non significatifs que la valeur entière doit afficher.Determine how many leading zeros you want the integer value to display.

  2. Déterminez si vous souhaitez afficher l'entier en tant que valeur décimale ou que valeur hexadécimale.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Une mise en forme en tant que valeur décimale nécessite l’utilisation du spécificateur de format standard « D ».Formatting it as a decimal value requires that you use the "D" standard format specifier.

    • Une mise en forme en tant que valeur hexadécimale nécessite l’utilisation du spécificateur de format standard « X ».Formatting it as a hexadecimal value requires that you use the "X" standard format specifier.

  3. Déterminez la longueur de la chaîne numérique non remplie en appelant la méthode ToString("D").Length ou ToString("X").Length de la valeur entière.Determine the length of the unpadded numeric string by calling the integer value's ToString("D").Length or ToString("X").Length method.

  4. Ajoutez le nombre de zéros non significatifs à inclure dans la chaîne mise en forme à la longueur de la chaîne numérique non remplie.Add the number of leading zeros that you want to include in the formatted string to the length of the unpadded numeric string. L’ajout du nombre de zéros non significatifs définit la longueur totale de la chaîne remplie.Adding the number of leading zeros defines the total length of the padded string.

  5. Appelez la méthode ToString(String) de la valeur entière, puis transmettez la chaîne « Dn » pour les chaînes décimales et la chaîne « Xn » pour les chaînes hexadécimales, où n représente la longueur totale de la chaîne remplie.Call the integer value's ToString(String) method, and pass the string "Dn" for decimal strings and "Xn" for hexadecimal strings, where n represents the total length of the padded string. Vous pouvez également utiliser la chaîne de format « Dn » ou « Xn » dans une méthode qui prend en charge la mise en forme composite.You can also use the "Dn" or "Xn" format string in a method that supports composite formatting.

L'exemple suivant remplit une valeur entière avec cinq zéros non significatifs.The following example pads an integer value with five leading zeros.

int value = 160934;
int decimalLength = value.ToString("D").Length + 5;
int hexLength = value.ToString("X").Length + 5;
Console.WriteLine(value.ToString("D" + decimalLength.ToString()));
Console.WriteLine(value.ToString("X" + hexLength.ToString()));
// The example displays the following output:
//       00000160934
//       00000274A6
Dim value As Integer = 160934
Dim decimalLength As Integer = value.ToString("D").Length + 5
Dim hexLength As Integer = value.ToString("X").Length + 5
Console.WriteLine(value.ToString("D" + decimalLength.ToString()))
Console.WriteLine(value.ToString("X" + hexLength.ToString()))
' The example displays the following output:
'       00000160934
'       00000274A6      

Pour remplir une valeur numérique avec des zéros non significatifs dans la limite d'une longueur spécifiqueTo pad a numeric value with leading zeros to a specific length

  1. Déterminez le nombre de chiffres à gauche du séparateur décimal qui doivent apparaître dans la représentation du nombre sous forme de chaîne.Determine how many digits to the left of the decimal you want the string representation of the number to have. Incluez des zéros non significatifs dans ce nombre total de chiffres.Include any leading zeros in this total number of digits.

  2. Définissez une chaîne de format numérique personnalisée qui utilise l’espace réservé du zéro « 0 » pour représenter le nombre minimal de zéros.Define a custom numeric format string that uses the zero placeholder "0" to represent the minimum number of zeros.

  3. Appelez la méthode ToString(String) du nombre et transmettez-lui la chaîne de format personnalisée.Call the number's ToString(String) method and pass it the custom format string. Vous pouvez également utiliser la chaîne de format personnalisée avec l’interpolation de chaîne ou avec une méthode qui prend en charge la mise en forme composite.You can also use the custom format string with string interpolation or with a method that supports composite formatting.

L’exemple suivant met en forme plusieurs valeurs numériques avec des zéros non significatifs.The following example formats several numeric values with leading zeros. Par conséquent, la longueur totale du nombre mis en forme est de huit chiffres minimum à gauche du séparateur décimal.As a result, the total length of the formatted number is at least eight digits to the left of the decimal.

string fmt = "00000000.##";
int intValue = 1053240;
decimal decValue = 103932.52m;
float sngValue = 1549230.10873992f;
double dblValue = 9034521202.93217412;

// Display the numbers using the ToString method.
Console.WriteLine(intValue.ToString(fmt));
Console.WriteLine(decValue.ToString(fmt));
Console.WriteLine(sngValue.ToString(fmt));
Console.WriteLine(dblValue.ToString(fmt));
Console.WriteLine();

// Display the numbers using composite formatting.
string formatString = " {0,15:" + fmt + "}";
Console.WriteLine(formatString, intValue);
Console.WriteLine(formatString, decValue);
Console.WriteLine(formatString, sngValue);
Console.WriteLine(formatString, dblValue);
// The example displays the following output:
//       01053240
//       00103932.52
//       01549230
//       9034521202.93
//
//               01053240
//            00103932.52
//               01549230
//          9034521202.93
Dim fmt As String = "00000000.##"
Dim intValue As Integer = 1053240
Dim decValue As Decimal = 103932.52d
Dim sngValue As Single = 1549230.10873992
Dim dblValue As Double = 9034521202.93217412

' Display the numbers using the ToString method.
Console.WriteLine(intValue.ToString(fmt))
Console.WriteLine(decValue.ToString(fmt))
Console.WriteLine(sngValue.ToString(fmt))
Console.WriteLine(dblValue.ToString(fmt))
Console.WriteLine()

' Display the numbers using composite formatting.
Dim formatString As String = " {0,15:" + fmt + "}"
Console.WriteLine(formatString, intValue)
Console.WriteLine(formatString, decValue)
Console.WriteLine(formatString, sngValue)
Console.WriteLine(formatString, dblValue)
' The example displays the following output:
'       01053240
'       00103932.52
'       01549230
'       9034521202.93
'       
'               01053240
'            00103932.52
'               01549230
'          9034521202.93      

Pour remplir une valeur numérique avec un nombre spécifique de zéros non significatifsTo pad a numeric value with a specific number of leading zeros

  1. Déterminez le nombre de zéros non significatifs que la valeur numérique doit avoir.Determine how many leading zeros you want the numeric value to have.

  2. Déterminez le nombre de chiffres à gauche du séparateur décimal dans la chaîne numérique non remplie :Determine the number of digits to the left of the decimal in the unpadded numeric string:

    1. Déterminez si la représentation sous forme de chaîne d'un nombre comprend un séparateur décimal.Determine whether the string representation of a number includes a decimal point symbol.

    2. Si tel est le cas, déterminez le nombre de caractères à gauche du séparateur décimal.If it does include a decimal point symbol, determine the number of characters to the left of the decimal point.

      -ou--or-

      Sinon, déterminez la longueur de la chaîne.If it doesn't include a decimal point symbol, determine the string's length.

  3. Créez une chaîne de format personnalisée qui utilise :Create a custom format string that uses:

    • L’espace réservé du zéro « 0 » pour chaque zéro non significatif qui apparaît dans la chaîne.The zero placeholder "0" for each of the leading zeros to appear in the string.

    • L’espace réservé du zéro ou l’espace réservé de chiffre « # » pour représenter chaque chiffre dans la chaîne par défaut.Either the zero placeholder or the digit placeholder "#" to represent each digit in the default string.

  4. Fournissez la chaîne de format personnalisée comme paramètre à la méthode ToString(String) du nombre ou à une méthode qui prend en charge la mise en forme composite.Supply the custom format string as a parameter either to the number's ToString(String) method or to a method that supports composite formatting.

L'exemple suivant remplit deux valeurs Double avec cinq zéros non significatifs.The following example pads two Double values with five leading zeros.

double[] dblValues = { 9034521202.93217412, 9034521202 };
foreach (double dblValue in dblValues)
{
   string decSeparator = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator;
   string fmt, formatString;

   if (dblValue.ToString().Contains(decSeparator))
   {
      int digits = dblValue.ToString().IndexOf(decSeparator);
      fmt = new String('0', 5) + new String('#', digits) + ".##";
   }
   else
   {
      fmt = new String('0', dblValue.ToString().Length);
   }
   formatString = "{0,20:" + fmt + "}";

   Console.WriteLine(dblValue.ToString(fmt));
   Console.WriteLine(formatString, dblValue);
}
// The example displays the following output:
//       000009034521202.93
//         000009034521202.93
//       9034521202
//                 9034521202
Dim dblValues() As Double = {9034521202.93217412, 9034521202}
For Each dblValue As Double In dblValues
    Dim decSeparator As String = System.Globalization.NumberFormatInfo.CurrentInfo.NumberDecimalSeparator
    Dim fmt, formatString As String

    If dblValue.ToString.Contains(decSeparator) Then
        Dim digits As Integer = dblValue.ToString().IndexOf(decSeparator)
        fmt = New String("0"c, 5) + New String("#"c, digits) + ".##"
    Else
        fmt = New String("0"c, dblValue.ToString.Length)
    End If
    formatString = "{0,20:" + fmt + "}"

    Console.WriteLine(dblValue.ToString(fmt))
    Console.WriteLine(formatString, dblValue)
Next
' The example displays the following output:
'       000009034521202.93
'         000009034521202.93
'       9034521202
'                 9034521202            

Voir aussiSee also