Compartilhar via


Como: Acrescentar um número com zeros

Você pode acrescentar um número inteiro com zeros à esquerda, usando o "D" seqüência de caracteres de formato numérico padrão juntamente com um especificador de precisão. Você pode acrescentar inteiro e números de ponto flutuante com zeros à esquerda, usando um seqüência de caracteres de formato numérico personalizado. Este tópico mostra como usar os dois métodos para acrescentar um número com zeros.

Para acrescentar um número inteiro com zeros à esquerda para um determinado período.

  1. Determine quantos dígitos que você deseja o valor inteiro para exibir. Inclua quaisquer dígitos líderes nesse número.

  2. Determine se você deseja exibir o número inteiro como um valor decimal ou hexadecimal.

    1. Para exibir o número inteiro como um valor decimal, ligue para seu ToString(String) método e passar a seqüência de caracteres "Dn" como o valor de format parâmetro, onde n representa o comprimento mínimo da seqüência de caracteres.

    2. Para exibir o número inteiro como um valor hexadecimal, ligue para seu ToString(String) método e passar a seqüência de caracteres "Xn" como o valor de format parâmetro, onde n representa o comprimento mínimo da seqüência de caracteres.

    Você também pode usar a seqüência de caracteres de formato em um método, como Format ou WriteLine, que usa formatação composto.

O exemplo a seguir formata vários valores de inteiros com zeros para que o comprimento total do número formatado pelo menos oito caracteres.

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 caling 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
byte byteValue = 254;
short shortValue = 10342;
int intValue = 1023983;
long lngValue = 6985321;               
ulong ulngValue = UInt64.MaxValue;

// Display integer values by caling 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

Para acrescentar um inteiro com um número específico de zeros à esquerda

  1. Determine quantos zeros à esquerda você deseja que o valor inteiro para exibir.

  2. Determine se você deseja exibir o número inteiro como um valor decimal ou hexadecimal. Formatá-lo como um valor decimal requer que você use o "D" especificador de formato padrão; formatá-lo como um valor hexadecimal requer que você use o "X" especificador de formato padrão.

  3. Determinar o comprimento da seqüência numérica unpadded chamando o valor de inteiro ToString("D").Length ou ToString("X").Length método.

  4. Adicione o número de zeros à esquerda que você deseja incluir na seqüência de caracteres formatada para o comprimento da seqüência numérica unpadded. Isso define o comprimento total da seqüência de caracteres macia.

  5. O valor de inteiro de chamar ToString(String) método e passar a seqüência de caracteres "Dn" para seqüências de caracteres decimais e "Xn" para seqüências de caracteres hexadecimais, onde n representa o comprimento total da seqüência de caracteres macia. Você também pode usar o "Dn" or "Xn" seqüência de caracteres de formato em um método que oferece suporte à formatação composto.

O exemplo a seguir pads um valor inteiro com cinco zeros à esquerda.

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      
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      

Para acrescentar um valor numérico com zeros à esquerda para um determinado período.

  1. Determine quantos dígitos à esquerda do decimal você deseja que a representação de seqüência de caracteres do número ter. Inclua os zeros à esquerda desse número total de dígitos.

  2. Defina uma seqüência de caracteres de formato numérico personalizado que usa o espaço reservado o para zero ("0") para representar o número mínimo de zeros.

  3. Ligue para o número ToString(String) método e passar a seqüência de caracteres de formato personalizado. Você também pode usar a seqüência de caracteres de formato personalizado com um método que oferece suporte à formatação composto.

O exemplo a seguir formata vários valores numéricos com zeros para que o comprimento total do número formatado pelo menos oito dígitos à esquerda da vírgula decimal.

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(sngValue.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
'       01549230
'       
'               01053240
'            00103932.52
'               01549230
'          9034521202.93      
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(sngValue.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
//       01549230
//       
//               01053240
//            00103932.52
//               01549230
//          9034521202.93      

Para acrescentar um valor numérico com um número específico de zeros à esquerda

  1. Determine quantos zeros à esquerda que o valor numérico que você deseja.

  2. Determine o número de dígitos à esquerda do decimal na seqüência numérica unpadded. Para fazer isso:

    1. Determine se a representação de seqüência de caracteres de um número inclui um símbolo de ponto decimal.

    2. Se ele incluir um símbolo de ponto decimal, determine o número de caracteres à esquerda da vírgula decimal.

      - ou -

      Se ele não incluir um símbolo de ponto decimal, determine o comprimento da seqüência de caracteres.

  3. Crie uma seqüência de caracteres de formato personalizado que usa o espaço reservado o para zero ("0") para cada os zeros apareça na seqüência de caracteres e que usa o espaço reservado para zero ou o espaço reservado para dígito ("#") para representar cada dígito na seqüência de caracteres padrão.

  4. Fornecer a seqüência de caracteres de formato personalizado como um parâmetro para o número ToString(String) método ou um método que oferece suporte à formatação de composição.

O exemplo a seguir pads dois Double valores com cinco zeros à esquerda.

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            
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            

Consulte também

Conceitos

Sequências de Caracteres de Formato Numérico Personalizado

Sequências de Caracteres de Formato Numérico Padrão

Formatação Composta