Postupy: Vyplnění čísla úvodními nulami

Můžete přidat počáteční nuly k celému číslu pomocí standardního číselného formátovacího řetězce "D" se specifikátorem přesnosti. Pomocí vlastního řetězce číselného formátulze přidat úvodní nuly k číslům Integer i s plovoucí desetinnou čárkou. Tento článek ukazuje, jak použít obě metody k vyplnění čísla počátečními nulami.

Vyplnění celého čísla počátečními nulami na určitou délku

  1. Určete minimální počet číslic, které mají být zobrazeny v celočíselné hodnotě. V tomto čísle uveďte všechny úvodní číslice.

  2. Určete, zda chcete zobrazit celé číslo jako desítkovou hodnotu nebo hexadecimální hodnotu.

    • Chcete-li zobrazit celé číslo jako desítkovou hodnotu, zavolejte svou ToString(String) metodu a předejte řetězec "D n" jako hodnotu format parametru, kde n představuje minimální délku řetězce.

    • Chcete-li zobrazit celé číslo jako šestnáctkovou hodnotu, zavolejte svou ToString(String) metodu a předejte řetězec "X n" jako hodnotu parametru Format, kde n představuje minimální délku řetězce.

Řetězec formátu lze použít také v řetězci v jazyce C# i Visual Basic, nebo můžete zavolat metodu, například String.Format nebo Console.WriteLine , která používá složené formátování.

Následující příklad formátuje několik celočíselných hodnot s počátečními nulami tak, aby celková délka formátovaného čísla byla alespoň osm znaků.

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

Chcete-li doplnit celé číslo s určitým počtem počátečních nul

  1. Určete, kolik počátečních nul má být celočíselná hodnota zobrazena.

  2. Určete, zda chcete zobrazit celé číslo jako desítkovou hodnotu nebo hexadecimální hodnotu.

    • Formátování jako Desítková hodnota vyžaduje použití specifikátoru standardního formátu "D".

    • Formátování jako hexadecimální hodnota vyžaduje použití specifikátoru standardního formátu "X".

  3. Určete délku nedoplněného číselného řetězce voláním celočíselné hodnoty ToString("D").Length nebo ToString("X").Length metody.

  4. Přidejte počet počátečních nul, které chcete zahrnout do formátovaného řetězce, na délku nedoplněného číselného řetězce. Přidání počtu počátečních nul definuje celkovou délku čalouněného řetězce.

  5. Zavolejte metodu celočíselné hodnoty ToString(String) a předejte řetězec "D n" pro desítkové řetězce a "X n" pro šestnáctkové řetězce, kde n představuje celkovou délku čalouněného řetězce. Můžete také použít formátovací řetězec "D n" nebo "X n" v metodě, která podporuje složené formátování.

V následujícím příkladu je celočíselná hodnota s pěti počátečními nulami.

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      

Vyplnění číselné hodnoty počátečními nulami na určitou délku

  1. Určete, kolik číslic nalevo od desetinné čárky má mít řetězcové vyjádření čísla. V tomto celkovém počtu číslic uveďte všechny úvodní nuly.

  2. Definujte vlastní řetězec číselného formátu, který používá nulový zástupný symbol "0" k vyjádření minimálního počtu nul.

  3. Zavolejte ToString(String) metodu Number a předejte jí vlastní formátovací řetězec. Můžete také použít vlastní řetězec formátu s interpolací řetězce nebo metodou, která podporuje složené formátování.

Následující příklad formátuje několik číselných hodnot s počátečními nulami. V důsledku toho je celková délka formátovaného čísla aspoň osm číslic nalevo od desetinné čárky.

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      

Vyplnění číselné hodnoty určitým počtem počátečních nul

  1. Určete, kolik počátečních nul má číselná hodnota.

  2. Určuje počet číslic nalevo od desetinné čárky v nedoplněném číselném řetězci:

    1. Určí, zda řetězcové vyjádření čísla obsahuje symbol desetinné čárky.

    2. Pokud obsahuje symbol desetinné čárky, určete počet znaků vlevo od desetinné čárky.

      -nebo-

      Pokud neobsahuje symbol desetinné čárky, určete délku řetězce.

  3. Vytvořte vlastní řetězec formátu, který používá:

    • Nulový zástupný symbol "0" pro každou počáteční nuly, která se má objevit v řetězci.

    • Zástupný symbol nula nebo zástupný symbol číslice "#" pro reprezentaci každé číslice ve výchozím řetězci.

  4. Zadejte řetězec vlastního formátu jako parametr buď do metody Number, ToString(String) nebo do metody, která podporuje složené formátování.

Následující příklad Double doplní dvě hodnoty pěti počátečními nulami.

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            

Viz také