Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Vous pouvez ajouter des zéros de tête à un entier en utilisant la chaîne de format numérique standard « D » avec un spécificateur de précision. Vous pouvez ajouter des zéros de tête aux nombres entiers et aux nombres à virgule flottante en utilisant une chaîne de format numérique personnalisée. Cet article montre comment utiliser les deux méthodes pour ajouter des zéros initiaux à un nombre.
Pour remplir un entier avec des zéros non significatifs dans la limite d'une longueur spécifique
Déterminez le nombre minimal de chiffres à afficher. Incluez tous les chiffres de début dans ce nombre.
Déterminez si vous souhaitez afficher l’entier sous forme de valeur décimale ou hexadécimale.
Pour afficher l’entier sous forme de valeur décimale, appelez sa
ToString(String)méthode et transmettez la chaîne « Dn » comme valeur duformatparamètre, où n représente la longueur minimale de la chaîne.Pour afficher l’entier sous forme de valeur hexadécimale, appelez sa
ToString(String)méthode et transmettez la chaîne « Xn » comme valeur du paramètre de format, où n représente la longueur minimale de la chaîne.
Vous pouvez également utiliser la chaîne de format dans une chaîne interpolée dans C# et Visual Basic. Vous pouvez également appeler une méthode telle que String.Format ou Console.WriteLine qui utilise la mise en forme composite.
L’exemple suivant met en forme plusieurs valeurs entières avec des zéros non significatifs afin que la longueur totale du nombre mis en forme soit au moins huit caractères.
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 significatifs
Déterminez combien de zéros initiaux vous souhaitez que la valeur entière affiche.
Déterminez si vous souhaitez afficher l’entier sous la forme d’une valeur décimale ou hexadécimale.
La mise en forme comme valeur décimale nécessite le spécificateur de format standard « D ».
La mise en forme en tant que valeur hexadécimale nécessite le spécificateur de format standard « X ».
Déterminez la longueur de la chaîne numérique non remplie en appelant la méthode
ToString("D").LengthouToString("X").Lengthde la valeur entière.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. Le résultat est la longueur totale de la chaîne rembourrée.
Appelez la méthode de la valeur entière
ToString(String)et passez la chaîne « Dn » pour les chaînes décimales et « Xn » pour les chaînes hexadécimales, où n représente la longueur totale de la chaîne complétée. 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.
L’exemple suivant montre comment compléter un nombre entier avec cinq zéros en tête.
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écifique
Déterminez le nombre de chiffres à gauche de la décimale que vous souhaitez que la représentation sous forme de chaîne du nombre ait. Incluez tous les zéros initiaux dans ce total de chiffres.
Définissez une chaîne de format numérique personnalisée qui utilise l’espace réservé zéro (« 0 ») pour représenter le nombre minimal de zéros.
Appelez la méthode
ToString(String)du nombre et transmettez-lui la chaîne de format personnalisée. Vous pouvez également utiliser la chaîne de format personnalisée avec l’interpolation de chaîne ou une méthode qui prend en charge la mise en forme composite.
L’exemple suivant formate plusieurs valeurs numériques avec des zéros initiaux. Par conséquent, la longueur totale du nombre mis en forme est d’au moins huit chiffres à gauche de la décimale.
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 significatifs
Déterminez combien de zéros initiaux vous voulez que la valeur numérique ait.
Déterminez le nombre de chiffres à gauche de la décimale dans la chaîne numérique non pavée :
Déterminez si la représentation sous forme de chaîne d’un nombre inclut un symbole décimal.
S’il inclut un symbole décimal, déterminez le nombre de caractères à gauche du point décimal. S’il n’inclut pas de symbole décimal, déterminez la longueur de la chaîne.
Créez une chaîne de format personnalisée qui utilise :
- L’espace réservé du zéro « 0 » pour chaque zéro non significatif qui apparaît dans la chaîne.
- Soit l’espace réservé zéro, soit l’espace réservé au chiffre « # » pour représenter chaque chiffre dans la chaîne par défaut.
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.
L’exemple suivant remplit deux valeurs Double avec cinq zéros non significatifs :
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 aussi
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
