Comment : remplir un nombre avec des zéros non significatifs
Vous pouvez compléter un entier avec des zéros non significatifs en utilisant la chaîne de format numérique standard "D" avec un spécificateur de précision. Vous pouvez compléter un entier et des nombres à virgule flottante avec des zéros non significatifs en utilisant une chaîne de format numérique personnalisée. Cette rubrique explique comment utiliser les deux méthodes pour compléter un nombre avec des zéros non significatifs.
Pour compléter un entier avec des zéros non significatifs jusqu'à une longueur spécifique
Déterminez combien de chiffres vous souhaitez que la valeur entière affiche. Incluez des chiffres à gauche dans ce nombre.
Déterminez si vous souhaitez afficher l'entier sous la forme d'une valeur décimale ou d'une valeur hexadécimale.
Pour afficher l'entier sous la forme d'une valeur décimale, appelez sa méthode ToString(String) et passez la chaîne "Dn" comme valeur du paramètre format, où n représente la longueur minimale de la chaîne.
Pour afficher l'entier sous la forme d'une valeur hexadécimale, appelez sa méthode ToString(String) et passez la chaîne "Xn" comme valeur du paramètre format, où n représente la longueur minimale de la chaîne.
Vous pouvez également utiliser la chaîne de format dans une méthode, telle que Format ou WriteLine, qui utilise la mise en forme composite.
L'exemple suivant met en forme plusieurs valeurs entières avec des zéros non significatifs de sorte que la longueur totale du nombre mis en forme soit d'au moins huit caractères.
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 caling 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
byte byteValue = 254;
short shortValue = 10342;
int intValue = 1023983;
long lngValue = 6985321;
ulong ulngValue = UInt64.MaxValue;
// Display integer values by caling 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
Pour compléter un entier avec un nombre spécifique de zéros non significatifs
Déterminez combien de zéros non significatifs 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 d'une valeur hexadécimale. Utilisez le spécificateur de format standard "D" pour l'afficher sous la forme d'une valeur décimale et le spécificateur de format standard "X" pour l'afficher sous la forme d'une valeur hexadécimale.
Déterminez la longueur de la chaîne numérique non complétée en appelant la méthode ToString("D").Length ou ToString("X").Length de la valeur entière.
Ajoutez le nombre de zéros non significatifs que vous souhaitez inclure dans la chaîne mise en forme pour atteindre la longueur de la chaîne numérique non complétée. Cela définit la longueur totale de la chaîne complétée.
Appelez la méthode ToString(String) de la valeur entière, puis 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 prenant en charge la mise en forme composite.
L'exemple suivant complète une valeur entière avec cinq zéros non significatifs.
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
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
Pour compléter une valeur numérique avec des zéros non significatifs jusqu'à une longueur spécifique
Déterminez combien de chiffres à gauche du séparateur décimal vous souhaitez faire apparaître dans la représentation sous forme de chaîne du nombre. Incluez des zéros non significatifs dans ce nombre total de chiffres.
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.
Appelez la méthode ToString(String) du nombre et passez-lui la chaîne de format personnalisée. Vous pouvez également utiliser la chaîne de format personnalisée avec une méthode prenant en charge la mise en forme composite.
L'exemple suivant met en forme plusieurs valeurs numériques avec des zéros non significatifs de sorte que la longueur totale du nombre mis en forme soit d'au moins huit chiffres à gauche du séparateur décimal.
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(sngValue.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
' 01549230
'
' 01053240
' 00103932.52
' 01549230
' 9034521202.93
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(sngValue.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
// 01549230
//
// 01053240
// 00103932.52
// 01549230
// 9034521202.93
Pour compléter une valeur numérique avec un nombre spécifique de zéros non significatifs
Déterminez combien de zéros non significatifs vous souhaitez que la valeur numérique contienne.
Déterminez le nombre de chiffres à gauche du séparateur décimal dans la chaîne numérique non complétée. Pour cela :
Déterminez si la représentation sous forme de chaîne d'un nombre inclut un symbole de séparateur décimal.
Si tel est le cas, déterminez le nombre de caractères à gauche de la virgule décimale.
ou
Sinon, 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 chacun des zéros non significatifs devant apparaître dans la chaîne, et qui utilise 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.
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 complète deux valeurs Double avec cinq zéros non significatifs.
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
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
Voir aussi
Concepts
Chaînes de format numériques personnalisées