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

Úvodní nuly můžete přidat do celého čísla pomocí standardního řetězce číselného formátu D s specifikátorem přesnosti. Úvodní nuly můžete přidat do celočíselných i čísel s plovoucí desetinnou čárkou pomocí vlastního řetězce číselného formátu. Tento článek ukazuje, jak pomocí obou metod vyvést číslo s úvodními nulami.

Nastavení celočíselného čísla s úvodními nulami na určitou délku

  1. Určete minimální počet číslic, které chcete zobrazit celočíselnou hodnotu. Do tohoto čísla zahrňte všechny úvodní číslice.

  2. Určete, jestli chcete celé číslo zobrazit jako desetinnou nebo šestnáctkovou hodnotu.

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

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

Můžete také použít formátovací řetězec v interpolovaném řetězci v jazyce C# i Visual Basic. Případně můžete volat metodu, například String.Format nebo Console.WriteLine která používá složené formátování.

Následující příklad naformátuje několik celočíselných hodnot s úvodními nulami, 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

Nastavení celočíselného čísla s určitým počtem úvodních nul

  1. Určete, kolik počátečních nul chcete zobrazit celočíselnou hodnotu.

  2. Určete, jestli chcete celé číslo zobrazit jako desetinné číslo nebo šestnáctkové hodnoty.

    • Formátování jako desetinné hodnoty vyžaduje specifikátor standardního formátu D.

    • Formátování jako šestnáctkové hodnoty vyžaduje specifikátor standardního formátu X.

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

  4. Přidejte k délce nepaddovaného číselného řetězce požadovaný počet úvodních nul v formátovaném řetězci. Výsledkem je celková délka vycpaného řetězce.

  5. Zavolejte metodu celočíselné hodnoty ToString(String) a předejte řetězec "Dn" pro desetinné řetězce a "Xn" pro šestnáctkové řetězce, kde n představuje celkovou délku vkládaná řetězce. Řetězec formátu "Dn" nebo "Xn" můžete použít také v metodě, která podporuje složené formátování.

Následující příklad vypíše celočíselnou hodnotu s pěti úvodní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      

Nastavení číselné hodnoty s úvodními nulami na určitou délku

  1. Určete, kolik číslic nalevo od desetinné čárky chcete mít řetězcovou reprezentaci čísla. Do tohoto celkového počtu číslic zahrňte všechny úvodní nuly.

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

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

Následující příklad naformátuje několik číselných hodnot s úvodními nulami. V důsledku toho je celková délka formátovaného čísla alespoň osm číslic vlevo 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      

Zadání číselné hodnoty s určitým počtem úvodních nul

  1. Určete, kolik úvodních nul chcete mít číselnou hodnotu.

  2. Určete počet číslic vlevo od desetinné čárky v nepaddovaném číselném řetězci:

    1. Určete, jestli řetězcová reprezentace čísla obsahuje symbol desetinné čárky.

    2. Pokud obsahuje symbol desetinné čárky, určete počet znaků vlevo od desetinné čárky. Pokud neobsahuje symbol desetinné čárky, určete délku řetězce.

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

    • Zástupný symbol nuly ("0") pro každý z úvodních nul se zobrazí v řetězci.

    • Zástupný symbol nuly nebo zástupný symbol číslice #, který bude představovat každou číslici ve výchozím řetězci.

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

Následující příklad obsahuje dvě Double hodnoty s pěti úvodní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é