Dela via

Instruktioner: Lägg till ett tal med inledande nollor

  • Artikel

Du kan lägga till inledande nollor i ett heltal med hjälp av standardsträngen D i numeriskt format med en precisionsspecificerare. Du kan lägga till inledande nollor i både heltals- och flyttalsnummer med hjälp av en anpassad numerisk formatsträng. Den här artikeln visar hur du använder båda metoderna för att fylla på ett tal med inledande nollor.

Så här fyller du ett heltal med inledande nollor till en viss längd

  1. Fastställ det minsta antalet siffror som du vill att heltalsvärdet ska visa. Inkludera inledande siffror i det här talet.

  2. Avgör om du vill visa heltalet som ett decimal- eller hexadecimalt värde.

    • Om du vill visa heltalet som ett decimalvärde anropar du dess ToString(String) metod och skickar strängen "Dn" som värdet för parametern format , där n representerar strängens minsta längd.

    • Om du vill visa heltalet som ett hexadecimalt värde anropar du dess ToString(String) metod och skickar strängen "Xn" som värdet för formatparametern, där n representerar strängens minsta längd.

Du kan också använda formatsträngen i en interpolerad sträng i både C# och Visual Basic. Du kan också anropa en metod som String.Format eller som använder sammansatt formateringConsole.WriteLine.

I följande exempel formateras flera heltalsvärden med inledande nollor så att den totala längden på det formaterade talet är minst åtta tecken.

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

Så här fyller du ut ett heltal med ett visst antal inledande nollor

  1. Avgör hur många inledande nollor du vill att heltalsvärdet ska visas.

  2. Avgör om du vill visa heltalet som ett decimalvärde eller ett hexadecimalt värde.

    • För att formatera det som ett decimalvärde krävs standardformatsspecificeraren "D".

    • För att formatera det som ett hexadecimalt värde krävs standardformatsspecificeraren "X".

  3. Fastställ längden på den opadderade numeriska strängen genom att anropa heltalsvärdets ToString("D").Length eller ToString("X").Length -metoden.

  4. Lägg till det antal inledande nollor som du vill ha i den formaterade strängen i längden på den opadderade numeriska strängen. Resultatet är den totala längden på den vadderade strängen.

  5. Anropa heltalsvärdets ToString(String) metod och skicka strängen "Dn" för decimalsträngar och "Xn" för hexadecimala strängar, där n representerar den totala längden på den vadderade strängen. Du kan också använda formatsträngen "Dn" eller "Xn" i en metod som stöder sammansatt formatering.

I följande exempel fylls ett heltalsvärde med fem inledande nollor:

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

Så här fyller du ett numeriskt värde med inledande nollor till en viss längd

  1. Bestäm hur många siffror till vänster om decimaltecknet som du vill att strängrepresentationen av talet ska ha. Inkludera inledande nollor i det här totala antalet siffror.

  2. Definiera en anpassad numerisk formatsträng som använder platshållaren noll ("0") för att representera det minsta antalet nollor.

  3. Anropa numrets ToString(String) metod och skicka den till den anpassade formatsträngen. Du kan också använda den anpassade formatsträngen med stränginterpolation eller en metod som stöder sammansatt formatering.

I följande exempel formateras flera numeriska värden med inledande nollor. Därför är den totala längden på det formaterade talet minst åtta siffror till vänster om decimaltecknet.

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

Så här fyller du ett numeriskt värde med ett specifikt antal inledande nollor

  1. Avgör hur många inledande nollor du vill att det numeriska värdet ska ha.

  2. Fastställ antalet siffror till vänster om decimaltecknet i den oskyddade numeriska strängen:

    1. Avgör om strängrepresentationen av ett tal innehåller en decimaltecken.

    2. Om den innehåller en decimalteckensymbol bestämmer du antalet tecken till vänster om decimaltecknet. Om den inte innehåller ett decimaltecken avgör du strängens längd.

  3. Skapa en anpassad formatsträng som använder:

    • Platshållaren noll ("0") för var och en av de inledande nollorna ska visas i strängen.

    • Platshållaren noll eller sifferplatshållaren "#" för att representera varje siffra i standardsträngen.

  4. Ange strängen för anpassat format som en parameter antingen till talets ToString(String) metod eller till en metod som stöder sammansatt formatering.

I följande exempel fylls två Double värden med fem inledande nollor:

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

Se även