Porady: uzupełnianie liczby zerami prowadzącymi

Można dodać zera wiodące do liczby całkowitej przy użyciu standardowego ciągu formatu liczbowego "D" z specyfikatorem dokładności. Można dodać zera wiodące zarówno do liczb całkowitych, jak i zmiennoprzecinkowych przy użyciu niestandardowego ciągu formatu liczbowego. W tym artykule pokazano, jak użyć obu metod, aby wypełnić liczbę z wiodącymi zerami.

Aby wypełnić liczbę całkowitą z wiodącymi zerami do określonej długości

1. Określ minimalną liczbę cyfr, które mają być wyświetlane dla wartości całkowitej. Uwzględnij wszystkie cyfry wiodące w tej liczbie.

2. Określ, czy chcesz wyświetlić liczbę całkowitą jako wartość dziesiętną, czy szesnastkowa.

   • Aby wyświetlić liczbę całkowitą jako wartość dziesiętną, wywołaj metodę ToString(String) i przekaż ciąg "Dn" jako wartość parametru format , gdzie n reprezentuje minimalną długość ciągu.

   • Aby wyświetlić liczbę całkowitą jako wartość szesnastkową, wywołaj metodę ToString(String) i przekaż ciąg "Xn" jako wartość parametru formatu, gdzie n reprezentuje minimalną długość ciągu.

Możesz również użyć ciągu formatu w ciągu interpolowanym w językach C# i Visual Basic. Alternatywnie można wywołać metodę, taką jak String.Format lub Console.WriteLine używającą formatowania złożonego.

Poniższy przykład formatuje kilka wartości całkowitych z zerami wiodącymi, aby łączna długość sformatowanej liczby wynosi co najmniej osiem znaków.

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

Aby wypełnić liczbę całkowitą z określoną liczbą zer wiodących

1. Określ liczbę zer wiodących, które mają być wyświetlane dla wartości całkowitej.

2. Określ, czy chcesz wyświetlić liczbę całkowitą jako wartość dziesiętną, czy szesnastkowa.

   • Formatowanie go jako wartości dziesiętnej wymaga specyfikatora formatu standardowego "D".

   • Formatowanie go jako wartości szesnastkowej wymaga specyfikatora formatu standardowego "X".

3. Określ długość niepaddowanego ciągu liczbowego przez wywołanie metody lub ToString("X").Length wartości ToString("D").Length całkowitej.

4. Dodaj do długości niepaddowanego ciągu liczbowego liczbę zer wiodących, które mają być w sformatowanym ciągu. Wynikiem jest łączna długość wyściełanego ciągu.

5. Wywołaj metodę wartości ToString(String) całkowitej i przekaż ciąg "Dn" dla ciągów dziesiętnych i "Xn" dla ciągów szesnastkowych, gdzie n reprezentuje łączną długość ciągu dopełnionego. Można również użyć ciągu formatu "Dn" lub "Xn" w metodzie obsługującej formatowanie złożone.

Poniższy przykład zawiera wartość całkowitą z pięcioma wiodącymi zerami:

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      

Aby wypełnić wartość liczbową z wiodącymi zerami do określonej długości

1. Określ, ile cyfr z lewej strony dziesiętnej ma mieć reprezentacja ciągu liczby. Uwzględnij wszystkie zera wiodące w tej całkowitej liczbie cyfr.

2. Zdefiniuj niestandardowy ciąg formatu liczbowego, który używa symbolu zastępczego zero ("0") do reprezentowania minimalnej liczby zer.

3. Wywołaj metodę numeru ToString(String) i przekaż go do ciągu formatu niestandardowego. Można również użyć niestandardowego ciągu formatu z interpolacją ciągów lub metodą, która obsługuje formatowanie złożone.

Poniższy przykład formatuje kilka wartości liczbowych z wiodącymi zerami. W związku z tym łączna długość sformatowanej liczby wynosi co najmniej osiem cyfr z lewej strony dziesiętnej.

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      

Aby wypełnić wartość liczbową z określoną liczbą zer wiodących

1. Określ, ile zer wiodących ma zawierać wartość liczbowa.

2. Określ liczbę cyfr z lewej strony dziesiętnej w ciągu liczbowym bez ściągniętym:

   1. Ustal, czy reprezentacja ciągu liczby zawiera symbol separatora dziesiętnego.

   2. Jeśli zawiera symbol separatora dziesiętnego, określ liczbę znaków z lewej strony punktu dziesiętnego. Jeśli nie zawiera symbolu punktu dziesiętnego, określ długość ciągu.

3. Utwórz niestandardowy ciąg formatu, który używa:

   • Symbol zastępczy zero ("0") dla każdego z zer wiodących do wyświetlenia w ciągu.

   • Symbol zastępczy zero lub symbol zastępczy cyfry "#" reprezentujący każdą cyfrę w ciągu domyślnym.

4. Podaj ciąg formatu niestandardowego jako parametr do metody number ToString(String) lub metody obsługującej formatowanie złożone.

Poniższy przykład zawiera dwie Double wartości z pięcioma wiodącymi zerami:

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            

Zobacz też

• Niestandardowe ciągi formatujące liczby
• Standardowe ciągi formatów liczbowych
• Złożone formatowanie