Instrukcje: Uzupełnianie liczby zerami wiodącymiHow to: Pad a Number with Leading Zeros

Można dodać Wiodące zera do liczby całkowitej przy użyciu standardowego ciągu formatu liczbowego "D" ze specyfikatorem dokładności.You can add leading zeros to an integer by using the "D" standard numeric format string with a precision specifier. Można dodać Wiodące zera do liczb całkowitych i zmiennoprzecinkowych przy użyciu niestandardowego ciągu formatu liczbowego.You can add leading zeros to both integer and floating-point numbers by using a custom numeric format string. W tym artykule pokazano, jak używać obu metod do uzupełniania liczby wiodących zer.This article shows how to use both methods to pad a number with leading zeros.

Aby uzupełnić liczbę całkowitą wiodącymi zerami do określonej długościTo pad an integer with leading zeros to a specific length

  1. Określ minimalną liczbę cyfr, jaka ma być wyświetlana wartość całkowita.Determine the minimum number of digits you want the integer value to display. Dołącz wszystkie znaki wiodące w tej liczbie.Include any leading digits in this number.

  2. Określ, czy chcesz wyświetlić liczbę całkowitą jako wartość dziesiętną, czy wartość szesnastkową.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

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

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

Możesz również użyć ciągu w formacie interpolowanym w języku C# i Visual Basiclub wywołać metodę, taką jak String.Format lub Console.WriteLine , która używa formatowania złożonego.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.

Poniższy przykład formatuje kilka wartości całkowitych wiodących zer, tak aby łączna długość sformatowanej liczby była co najmniej 8 znaków.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

Aby uzupełnić liczbę całkowitą z określoną liczbą zer wiodącychTo pad an integer with a specific number of leading zeros

  1. Określ, ile wiodących zer ma być wyświetlana wartość całkowita.Determine how many leading zeros you want the integer value to display.

  2. Określ, czy chcesz wyświetlić liczbę całkowitą jako wartość dziesiętną, czy wartość szesnastkową.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Formatowanie go jako wartości dziesiętnej wymaga użycia specyfikatora formatu standardowego "D".Formatting it as a decimal value requires that you use the "D" standard format specifier.

    • Formatowanie go jako wartości szesnastkowej wymaga użycia specyfikatora formatu standardowego "X".Formatting it as a hexadecimal value requires that you use the "X" standard format specifier.

  3. Ustal długość nieuzupełnionego ciągu liczbowego, wywołując wartość typu Integer ToString("D").Length lub ToString("X").Length metodę.Determine the length of the unpadded numeric string by calling the integer value's ToString("D").Length or ToString("X").Length method.

  4. Dodaj liczbę zer wiodących, które mają być uwzględnione w ciągu sformatowanym do długości nieuzupełnionego ciągu liczbowego.Add the number of leading zeros that you want to include in the formatted string to the length of the unpadded numeric string. Dodanie liczby zer wiodących określa łączną długość uzupełnionego ciągu.Adding the number of leading zeros defines the total length of the padded string.

  5. Wywołaj metodę wartości całkowitej ToString(String) i przekaż ciąg "Dn" dla ciągów dziesiętnych i "Xn" dla ciągów szesnastkowych, gdzie n reprezentuje łączną długość uzupełnionego ciągu.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. Można również użyć ciągu formatu "Dn" lub "Xn" w metodzie, która obsługuje formatowanie złożone.You can also use the "Dn" or "Xn" format string in a method that supports composite formatting.

Poniższy przykład ilustruje liczbę całkowitą z pięciu wiodących zer.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      

Aby uzupełnić wartość liczbową wiodącymi zerami do określonej długościTo pad a numeric value with leading zeros to a specific length

  1. Określ liczbę cyfr po lewej stronie przecinka dziesiętnego, w ciągu którego ma zostać wystawiona liczba.Determine how many digits to the left of the decimal you want the string representation of the number to have. Dołącz wszystkie zera wiodące w tej łącznej liczbie cyfr.Include any leading zeros in this total number of digits.

  2. Zdefiniuj niestandardowy ciąg formatu liczbowego, który używa symbolu zastępczego zero "0" do reprezentowania minimalnej liczby zer.Define a custom numeric format string that uses the zero placeholder "0" to represent the minimum number of zeros.

  3. Wywołaj metodę Number ToString(String) i przekaż ją do niestandardowym ciągiem formatu.Call the number's ToString(String) method and pass it the custom format string. Można również użyć niestandardowego ciągu formatu z interpolacją ciągu lub metodą, która obsługuje formatowanie złożone.You can also use the custom format string with string interpolation or with a method that supports composite formatting.

Poniższy przykład formatuje kilka wartości liczbowych z zerami wiodącymi.The following example formats several numeric values with leading zeros. W związku z tym łączna długość sformatowanej liczby ma co najmniej osiem cyfr z lewej strony dziesiętnej.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      

Aby uzupełnić wartość numeryczną określoną liczbą zer wiodącychTo pad a numeric value with a specific number of leading zeros

  1. Określ, ile wiodących zer ma mieć wartość liczbową.Determine how many leading zeros you want the numeric value to have.

  2. Określ liczbę cyfr po lewej stronie przecinka dziesiętnego w nieuzupełnionym ciągu liczbowym:Determine the number of digits to the left of the decimal in the unpadded numeric string:

    1. Ustal, czy ciąg reprezentujący liczbę zawiera symbol separatora dziesiętnego.Determine whether the string representation of a number includes a decimal point symbol.

    2. Jeśli zawiera symbol separatora dziesiętnego, należy określić liczbę znaków po lewej stronie przecinka dziesiętnego.If it does include a decimal point symbol, determine the number of characters to the left of the decimal point.

      -lub--or-

      Jeśli nie zawiera symbolu punktu dziesiętnego, ustal długość ciągu.If it doesn't include a decimal point symbol, determine the string's length.

  3. Utwórz niestandardowy ciąg formatujący, który używa:Create a custom format string that uses:

    • Symbol zastępczy zero "0" dla każdego wiodącego zera, który ma być wyświetlany w ciągu.The zero placeholder "0" for each of the leading zeros to appear in the string.

    • Symbol zastępczy zero lub symbol zastępczy cyfry "#" reprezentujący każdą cyfrę w postaci ciągu domyślnego.Either the zero placeholder or the digit placeholder "#" to represent each digit in the default string.

  4. Podaj ciąg formatu niestandardowego jako parametr do ToString(String) metody Number lub do metody, która obsługuje formatowanie złożone.Supply the custom format string as a parameter either to the number's ToString(String) method or to a method that supports composite formatting.

W poniższym przykładzie są umieszczane dwie Double wartości z pięciu wiodących zer.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            

Zobacz takżeSee also