Delen via

Procedure: Een getal opvulen met voorloopnullen

  • Artikel

U kunt voorloopnullen toevoegen aan een geheel getal met behulp van de standaardtekenreeks voor numerieke notatie D met een precisieaanduiding. U kunt voorloopnullen toevoegen aan zowel gehele getallen als getallen met drijvende komma met behulp van een aangepaste tekenreeks voor numerieke notatie. In dit artikel wordt beschreven hoe u beide methoden gebruikt om een getal te gebruiken met voorloopnullen.

Een geheel getal met voorloopnullen op een bepaalde lengte opvulling geven

  1. Bepaal het minimumaantal cijfers dat de waarde voor het gehele getal moet weergeven. Neem eventuele voorloopcijfers op in dit getal.

  2. Bepaal of u het gehele getal wilt weergeven als een decimale of hexadecimale waarde.

    • Als u het gehele getal wilt weergeven als een decimale waarde, roept u de methode aan ToString(String) en geeft u de tekenreeks 'Dn' door als de waarde van de format parameter, waarbij n de minimale lengte van de tekenreeks aangeeft.

    • Als u het gehele getal wilt weergeven als een hexadecimale waarde, roept u de methode aan ToString(String) en geeft u de tekenreeks 'Xn' door als de waarde van de notatieparameter, waarbij n de minimale lengte van de tekenreeks vertegenwoordigt.

U kunt de notatietekenreeks ook gebruiken in een geïnterpoleerde tekenreeks in zowel C# als Visual Basic. U kunt ook een methode aanroepen, zoals String.Format of Console.WriteLine die gebruikmaakt van samengestelde opmaak.

In het volgende voorbeeld worden verschillende gehele getallen met voorloopnullen opgemaakt, zodat de totale lengte van het opgemaakte getal ten minste acht tekens is.

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

Een geheel getal met een bepaald aantal voorloopnullen opvulling geven

  1. Bepaal hoeveel voorloopnullen de waarde voor het gehele getal moet weergeven.

  2. Bepaal of u het gehele getal wilt weergeven als een decimaal getal of een hexadecimale waarde.

    • Voor het opmaken als een decimale waarde is de standaardnotatieaanduiding D vereist.

    • Voor het opmaken als een hexadecimale waarde is de standaardnotatieaanduiding X vereist.

  3. Bepaal de lengte van de niet-toegewezen numerieke tekenreeks door de waarde of ToString("X").Length methode van ToString("D").Length het gehele getal aan te roepen.

  4. Voeg het aantal voorloopnullen toe dat u in de opgemaakte tekenreeks wilt toevoegen aan de lengte van de niet-aangepaste numerieke tekenreeks. Het resultaat is de totale lengte van de opgevulde tekenreeks.

  5. Roep de methode van ToString(String) de gehele waarde aan en geef de tekenreeks 'Dn' door voor decimale tekenreeksen en Xn voor hexadecimale tekenreeksen, waarbij n de totale lengte van de opgevulde tekenreeks aangeeft. U kunt ook de notatietekenreeks Dn of Xn gebruiken in een methode die samengestelde opmaak ondersteunt.

In het volgende voorbeeld wordt een geheel getal met vijf voorloopnullen opgeslagen:

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

Een numerieke waarde met voorloopnullen op een bepaalde lengte instellen

  1. Bepaal hoeveel cijfers links van het decimaal getal de tekenreeksweergave van het getal moeten hebben. Neem eventuele voorloopnullen op in dit totale aantal cijfers.

  2. Definieer een tekenreeks met een aangepaste numerieke notatie die gebruikmaakt van de tijdelijke aanduiding nul ('0') om het minimumaantal nullen weer te geven.

  3. Roep de methode van ToString(String) het nummer aan en geef deze door aan de tekenreeks voor aangepaste notatie. U kunt ook de tekenreeks voor aangepaste notatie gebruiken met tekenreeksinterpolatie of een methode die samengestelde opmaak ondersteunt.

In het volgende voorbeeld worden verschillende numerieke waarden opgemaakt met voorloopnullen. Als gevolg hiervan is de totale lengte van het opgemaakte getal ten minste acht cijfers links van het decimaalteken.

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

Een numerieke waarde opvulling geven met een specifiek aantal voorloopnullen

  1. Bepaal hoeveel voorloopnullen u de numerieke waarde wilt hebben.

  2. Bepaal het aantal cijfers links van het decimaalteken in de niet-gepadde numerieke tekenreeks:

    1. Bepaal of de tekenreeksweergave van een getal een decimaalteken bevat.

    2. Als het een decimaalteken bevat, bepaalt u het aantal tekens links van het decimaalteken. Als het geen decimaalteken bevat, bepaalt u de lengte van de tekenreeks.

  3. Maak een tekenreeks met een aangepaste notatie die gebruikmaakt van:

    • De tijdelijke aanduiding nul ('0') voor elk van de voorloopnullen die in de tekenreeks worden weergegeven.

    • De tijdelijke aanduiding nul of de tijdelijke aanduiding voor cijfers '#' om elk cijfer in de standaardtekenreeks weer te geven.

  4. Geef de tekenreeks voor aangepaste notatie op als parameter voor de methode van ToString(String) het getal of aan een methode die samengestelde opmaak ondersteunt.

In het volgende voorbeeld worden twee Double waarden met vijf voorloopnullen opgevuld:

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

Zie ook