Vorgehensweise: Auffüllen einer Zahl mit führenden NullenHow to: Pad a Number with Leading Zeros

Führende Nullen können Sie mithilfe der numerischen Standardformatzeichenfolge „D“ zusammen mit einem Genauigkeitsbezeichner zu einer Ganzzahl hinzufügen.You can add leading zeros to an integer by using the "D" standard numeric format string with a precision specifier. Ganz- und Gleitkommazahlen können Sie führende Nullen mithilfe einer benutzerdefinierten numerischen Formatzeichenfolge hinzufügen.You can add leading zeros to both integer and floating-point numbers by using a custom numeric format string. In diesem Artikel lernen Sie beide Methoden zum Auffüllen einer Zahl mit führenden Nullen kennen.This article shows how to use both methods to pad a number with leading zeros.

Ganzzahl bis zu einer bestimmten Länge mit führenden Nullen auffüllenTo pad an integer with leading zeros to a specific length

  1. Bestimmen Sie die Mindestanzahl an Ziffern, die der Ganzzahlwert anzeigen soll.Determine the minimum number of digits you want the integer value to display. Schließen Sie alle führenden Ziffern in diese Zahl ein.Include any leading digits in this number.

  2. Bestimmen Sie, ob die Ganzzahl als Dezimalwert oder als Hexadezimalwert angezeigt werden soll.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Um sie als Dezimalwert anzuzeigen, rufen Sie ihre ToString(String)-Methode auf, und übergeben Sie die Zeichenfolge "Dn" als Wert des format-Parameters, wobei n die minimale Länge der Zeichenfolge darstellt.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.

    • Um die ganze Zahl als Hexadezimalwert anzuzeigen, rufen Sie ihre ToString(String)-Methode auf, und übergeben Sie die Zeichenfolge „Xn“ als Wert des format-Parameters, wobei n die Mindestlänge der Zeichenfolge darstellt.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.

Sie können auch die Formatzeichenfolge in einer interpolierten Zeichenfolge sowohl in C# als auch Visual Basic verwenden, oder Sie können eine Methode aufrufen, z. B. String.Format oder Console.WriteLine, die kombinierte Formatierung verwendet.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.

Im folgenden Beispiel sind mehrere Ganzzahlwerte so mit führenden Nullen formatiert, dass die Gesamtlänge der formatierten Zahl mindestens acht Zeichen beträgt.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

Ganzzahl mit einer bestimmten Anzahl führender Nullen auffüllenTo pad an integer with a specific number of leading zeros

  1. Bestimmen Sie, wie viele führende Nullen der Ganzzahlwert anzeigen soll.Determine how many leading zeros you want the integer value to display.

  2. Bestimmen Sie, ob die Ganzzahl als Dezimalwert oder als Hexadezimalwert angezeigt werden soll.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Das Formatieren der Ganzzahl als Dezimalwert erfordert die Verwendung des Standardformatbezeichners „D“.Formatting it as a decimal value requires that you use the "D" standard format specifier.

    • Das Formatieren der Ganzzahl als Hexadezimalwert erfordert die Verwendung des Standardformatbezeichners „X“.Formatting it as a hexadecimal value requires that you use the "X" standard format specifier.

  3. Bestimmen Sie die Länge der noch nicht mit Nullen aufgefüllten numerischen Zeichenfolge, indem Sie die ToString("D").Length- oder die ToString("X").Length-Methode des Ganzzahlwerts aufrufen.Determine the length of the unpadded numeric string by calling the integer value's ToString("D").Length or ToString("X").Length method.

  4. Fügen Sie die Anzahl der führenden Nullen, die in die formatierte Zeichenfolge eingefügt werden sollen, zur Länge der nicht aufgefüllten numerischen Zeichenfolge hinzu.Add the number of leading zeros that you want to include in the formatted string to the length of the unpadded numeric string. Durch Hinzufügen der Anzahl der führenden Nullen wird die Gesamtlänge der aufgefüllten Zeichenfolge definiert.Adding the number of leading zeros defines the total length of the padded string.

  5. Rufen Sie die ToString(String)-Methode des Ganzzahlwerts auf, und übergeben Sie die Zeichenfolge „Dn“ für Dezimalzeichenfolgen und „Xn“ für Hexadezimalzeichenfolgen, wobei n die Gesamtlänge der aufgefüllten Zeichenfolge darstellt.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. Sie können die Formatzeichenfolge „Dn“ oder „Xn“ auch in Methoden verwenden, die die kombinierte Formatierung unterstützen.You can also use the "Dn" or "Xn" format string in a method that supports composite formatting.

Im folgenden Beispiel wird ein Ganzzahlwert mit fünf führenden Nullen aufgefüllt.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      

Numerischen Wert bis zu einer bestimmten Länge mit führenden Nullen auffüllenTo pad a numeric value with leading zeros to a specific length

  1. Bestimmen Sie, über wie viele Ziffern links des Dezimaltrennzeichens die Zeichenfolgendarstellung der Zahl verfügen soll.Determine how many digits to the left of the decimal you want the string representation of the number to have. Schließen Sie alle führenden Nullen in diese Gesamtzahl der Ziffern ein.Include any leading zeros in this total number of digits.

  2. Definieren Sie eine benutzerdefinierte numerische Formatzeichenfolge, in der die Mindestanzahl an Nullen mit dem Null-Platzhalter („0“) dargestellt wird.Define a custom numeric format string that uses the zero placeholder "0" to represent the minimum number of zeros.

  3. Rufen Sie die ToString(String)-Methode der Zahl auf und übergeben sie die benutzerdefinierte Formatzeichenfolge.Call the number's ToString(String) method and pass it the custom format string. Sie können die benutzerdefinierte Formatzeichenfolge auch mit Zeichenfolgeninterpolation oder mit Methoden verwenden, die kombinierte Formatierung unterstützen.You can also use the custom format string with string interpolation or with a method that supports composite formatting.

Im folgenden Beispiel werden mehrere numerische Werte mit führenden Nullen formatiert.The following example formats several numeric values with leading zeros. Daher beträgt die Gesamtlänge der formatierten Zahl links vom Dezimaltrennzeichen mindestens acht Ziffern.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      

Numerischen Wert mit einer bestimmten Anzahl führender Nullen auffüllenTo pad a numeric value with a specific number of leading zeros

  1. Bestimmen Sie, über wie viele führende Nullen der numerische Wert verfügen soll.Determine how many leading zeros you want the numeric value to have.

  2. Bestimmen Sie die Anzahl der Ziffern links des Dezimaltrennzeichens in der nicht aufgefüllten numerischen Zeichenfolge:Determine the number of digits to the left of the decimal in the unpadded numeric string:

    1. Bestimmen Sie, ob die Zeichenfolgendarstellung der Zahl ein Symbol für das Dezimaltrennzeichen beinhaltet.Determine whether the string representation of a number includes a decimal point symbol.

    2. Wenn sie ein Dezimaltrennzeichen enthält, bestimmen Sie die Anzahl der Zeichen links des Dezimaltrennzeichens.If it does include a decimal point symbol, determine the number of characters to the left of the decimal point.

      Oder-or-

      Wenn sie kein Dezimaltrennzeichen enthält, bestimmen Sie die Länge der Zeichenfolge.If it doesn't include a decimal point symbol, determine the string's length.

  3. Erstellen Sie eine benutzerdefinierte Formatzeichenfolge, die Folgendes verwendet:Create a custom format string that uses:

    • Den Nullplatzhalter „0“ für jede der führenden Nullen, die in der Zeichenfolge enthalten sein soll.The zero placeholder "0" for each of the leading zeros to appear in the string.

    • Entweder den Nullplatzhalter oder den Ziffernplatzhalter „#“ zur Darstellung der einzelnen Ziffern in der Standardzeichenfolge.Either the zero placeholder or the digit placeholder "#" to represent each digit in the default string.

  4. Übergeben Sie die benutzerdefinierte Formatzeichenfolge als Parameter an die ToString(String)-Methode der Zahl oder an eine Methode, die kombinierte Formatierung unterstützt.Supply the custom format string as a parameter either to the number's ToString(String) method or to a method that supports composite formatting.

Im folgenden Beispiel werden zwei Double-Werte mit fünf führenden Nullen aufgefüllt.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            

Siehe auchSee also