Vorgehensweise: Auffüllen einer Zahl mit führenden Nullen

  • Artikel

Führende Nullen können Sie mithilfe der numerischen Standardformatzeichenfolge „D“ zusammen mit einem Genauigkeitsbezeichner zu einer Ganzzahl hinzufügen. Ganz- und Gleitkommazahlen können Sie führende Nullen mithilfe einer benutzerdefinierten numerischen Formatzeichenfolge hinzufügen. In diesem Artikel lernen Sie beide Methoden zum Auffüllen einer Zahl mit führenden Nullen kennen.

Ganzzahl bis zu einer bestimmten Länge mit führenden Nullen auffüllen

  1. Bestimmen Sie die Mindestanzahl an Ziffern, die der Ganzzahlwert anzeigen soll. Schließen Sie alle führenden Ziffern in diese Zahl ein.

  2. Bestimmen Sie, ob die Ganzzahl als Dezimalwert oder als Hexadezimalwert angezeigt werden soll.

    • 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.

    • 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.

Sie können die Formatzeichenfolge auch in einer interpolierten Zeichenfolge in C# und Visual Basicverwenden. Alternativ können Sie eine Methode wie String.Format oder Console.WriteLine aufrufen, die zusammengesetzte Formatierung verwendet.

Im folgenden Beispiel sind mehrere Ganzzahlwerte so mit führenden Nullen formatiert, dass die Gesamtlänge der formatierten Zahl mindestens acht Zeichen beträgt.

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üllen

  1. Bestimmen Sie, wie viele führende Nullen der Ganzzahlwert anzeigen soll.

  2. Bestimmen Sie, ob die Ganzzahl als Dezimalwert oder als Hexadezimalwert angezeigt werden soll.

    • Das Formatieren der Ganzzahl als Dezimalwert erfordert die Verwendung des Standardformatbezeichners „D“.

    • Das Formatieren der Ganzzahl als Hexadezimalwert erfordert die Verwendung des Standardformatbezeichners „X“.

  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.

  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. Dies ergibt die Gesamtlänge der mit Nullen aufgefüllten Zeichenfolge.

  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. Sie können die Formatzeichenfolge „Dn“ oder „Xn“ auch in Methoden verwenden, die die kombinierte Formatierung unterstützen.

Im folgenden Beispiel wird ein Ganzzahlwert mit fünf führenden Nullen aufgefüllt:

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üllen

  1. Bestimmen Sie, über wie viele Ziffern links des Dezimaltrennzeichens die Zeichenfolgendarstellung der Zahl verfügen soll. Schließen Sie alle führenden Nullen in diese Gesamtzahl der Ziffern ein.

  2. Definieren Sie eine benutzerdefinierte numerische Formatzeichenfolge, in der die Mindestanzahl an Nullen mit dem Null-Platzhalter ("0") dargestellt wird.

  3. Rufen Sie die ToString(String)-Methode der Zahl auf und übergeben sie die benutzerdefinierte Formatzeichenfolge. Sie können die benutzerdefinierte Formatzeichenfolge auch mit Zeichenfolgeninterpolation oder mit Methoden verwenden, die kombinierte Formatierung unterstützen.

Im folgenden Beispiel werden mehrere numerische Werte mit führenden Nullen formatiert. Daher beträgt die Gesamtlänge der formatierten Zahl links vom Dezimaltrennzeichen mindestens acht Ziffern.

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üllen

  1. Bestimmen Sie, über wie viele führende Nullen der numerische Wert verfügen soll.

  2. Bestimmen Sie die Anzahl der Ziffern links des Dezimaltrennzeichens in der nicht aufgefüllten numerischen Zeichenfolge:

    1. Bestimmen Sie, ob die Zeichenfolgendarstellung der Zahl ein Symbol für das Dezimaltrennzeichen beinhaltet.

    2. Wenn sie ein Dezimaltrennzeichen enthält, bestimmen Sie die Anzahl der Zeichen links des Dezimaltrennzeichens. Wenn sie kein Dezimaltrennzeichen enthält, bestimmen Sie die Länge der Zeichenfolge.

  3. Erstellen Sie eine benutzerdefinierte Formatzeichenfolge, die Folgendes verwendet:

    • Den Nullplatzhalter („0“) für jede der führenden Nullen, die in der Zeichenfolge enthalten sein soll.

    • Entweder den Nullplatzhalter oder den Ziffernplatzhalter „#“ zur Darstellung der einzelnen Ziffern in der Standardzeichenfolge.

  4. Übergeben Sie die benutzerdefinierte Formatzeichenfolge als Parameter an die ToString(String)-Methode der Zahl oder an eine Methode, die kombinierte Formatierung unterstützt.

Im folgenden Beispiel werden zwei Double-Werte mit fünf führenden Nullen aufgefüllt:

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 auch