Como preencher um número com zeros à esquerdaHow to: Pad a Number with Leading Zeros

É possível adicionar zeros à esquerda de um inteiro usando a cadeia de caracteres de formato numérico padrão “D” com um especificador de precisão.You can add leading zeros to an integer by using the "D" standard numeric format string with a precision specifier. Você pode adicionar zeros à esquerda de inteiros e pontos flutuantes usando uma cadeia de caracteres de formato numérico personalizado.You can add leading zeros to both integer and floating-point numbers by using a custom numeric format string. Este artigo mostra como usar os dois métodos para preencher um número com zeros à esquerda.This article shows how to use both methods to pad a number with leading zeros.

Para acrescentar um número inteiro com zeros à esquerda com um comprimento específicoTo pad an integer with leading zeros to a specific length

  1. Determine o número mínimo de dígitos que o valor inteiro deve exibir.Determine the minimum number of digits you want the integer value to display. Inclua os dígitos à esquerda nesse número.Include any leading digits in this number.

  2. Determine se quer exibir o inteiro como valor decimal ou hexadecimal.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Para exibir o inteiro como um valor decimal, chame seu método ToString(String) e passe a cadeia de caracteres "Dn" como o valor do parâmetro format, em que n representa o tamanho mínimo da cadeia de caracteres.To display the integer as a decimal value, call its ToString(String) method, and pass the string "Dn" as the value of the format parameter, where n represents the minimum length of the string.

    • Para exibir o número inteiro como hexadecimal, chame seu método ToString(String) e informe a cadeia de caracteres “Xn” como valor do parâmetro format, em que n representa o comprimento mínimo da cadeia de caracteres.To display the integer as a hexadecimal value, call its ToString(String) method and pass the string "Xn" as the value of the format parameter, where n represents the minimum length of the string.

Você também pode usar a cadeia de caracteres de formato em uma cadeia de caracteres interpolada em C# e em Visual Basic ou você pode chamar um método, como String.Format ou Console.WriteLine, que usa a formatação de composição.You can also use the format string in an interpolated string in both C# and Visual Basic, or you can call a method, such as String.Format or Console.WriteLine, that uses composite formatting.

O exemplo a seguir formata diversos valores inteiros com zeros à esquerda para que o comprimento total do número formatado tenha pelo menos oito caracteres.The following example formats several integer values with leading zeros so that the total length of the formatted number is at least eight characters.

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

Para acrescentar um número inteiro com uma determinada quantidade de zeros à esquerdaTo pad an integer with a specific number of leading zeros

  1. Determine quantos zeros à esquerda o valor inteiro deve exibir.Determine how many leading zeros you want the integer value to display.

  2. Determine se quer exibir o inteiro como valor decimal ou hexadecimal.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • A formatação como um valor decimal requer que você use o especificador de formato padrão "D".Formatting it as a decimal value requires that you use the "D" standard format specifier.

    • A formatação como um valor hexadecimal requer que você use o especificador de formato padrão "X".Formatting it as a hexadecimal value requires that you use the "X" standard format specifier.

  3. Determine o comprimento da cadeia de caracteres numérica não acrescentada. Para isso, chame o método ToString("D").Length ou ToString("X").Length do valor inteiro.Determine the length of the unpadded numeric string by calling the integer value's ToString("D").Length or ToString("X").Length method.

  4. Adicione quantos dígitos zero à esquerda quer incluir na cadeia de caracteres formatada com comprimento da cadeia de caracteres numérica não acrescentada.Add the number of leading zeros that you want to include in the formatted string to the length of the unpadded numeric string. A adição do número de zeros à esquerda define o comprimento total da cadeia de caracteres preenchida.Adding the number of leading zeros defines the total length of the padded string.

  5. Chame o método ToString(String) do valor inteiro e informe a cadeia de caracteres “Dn” para cadeias de caracteres decimais e “Xn” para cadeias de caracteres hexadecimais, em que n representa o comprimento total da cadeia de caracteres acrescentada.Call the integer value's ToString(String) method, and pass the string "Dn" for decimal strings and "Xn" for hexadecimal strings, where n represents the total length of the padded string. Você também pode usar uma cadeia de caracteres de formato “Dn” ou “Xn” em um método com suporte para formatação de composição.You can also use the "Dn" or "Xn" format string in a method that supports composite formatting.

O exemplo a seguir acrescenta um valor inteiro com cinco dígitos zero à esquerda.The following example pads an integer value with five leading zeros.

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      

Para acrescentar um valor numérico com zeros à esquerda com comprimento específicoTo pad a numeric value with leading zeros to a specific length

  1. Determine quantos dígitos a representação da cadeia de caracteres de números deve ter à esquerda dos decimais.Determine how many digits to the left of the decimal you want the string representation of the number to have. Inclua os dígitos zero à esquerda no número total de dígitos.Include any leading zeros in this total number of digits.

  2. Defina uma cadeia de caracteres de formato numérico personalizado que usa o espaço reservado para zero “0” para representar a quantidade mínima de dígitos zero.Define a custom numeric format string that uses the zero placeholder "0" to represent the minimum number of zeros.

  3. Chame o método ToString(String) do número e apresente-o à cadeia de caracteres de formato personalizado.Call the number's ToString(String) method and pass it the custom format string. Você também pode usar uma cadeia de caracteres de formato personalizado com interpolação de cadeia de caracteres ou um método com suporte para formatação de composição.You can also use the custom format string with string interpolation or with a method that supports composite formatting.

O exemplo a seguir formata diversos valores numéricos com zeros à esquerda.The following example formats several numeric values with leading zeros. Como resultado, o comprimento total do número formatado é pelo menos oito dígitos à esquerda do separador decimal.As a result, the total length of the formatted number is at least eight digits to the left of the decimal.

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      

Para acrescentar um valor numérico com uma determinada quantidade de zeros à esquerdaTo pad a numeric value with a specific number of leading zeros

  1. Determine quantos zeros à esquerda o valor numérico deve ter.Determine how many leading zeros you want the numeric value to have.

  2. Determine a quantidade de dígitos à esquerda do decimal na cadeia de caracteres numéricos não preenchida:Determine the number of digits to the left of the decimal in the unpadded numeric string:

    1. Determine se a representação da cadeia de caracteres de um número inclui um símbolo de ponto decimal.Determine whether the string representation of a number includes a decimal point symbol.

    2. Caso o símbolo esteja presente, determine a quantidade de caracteres à esquerda do ponto decimal.If it does include a decimal point symbol, determine the number of characters to the left of the decimal point.

      - ou --or-

      Caso o símbolo de decimal não esteja presente, determine o comprimento da cadeia de caracteres.If it doesn't include a decimal point symbol, determine the string's length.

  3. Crie uma cadeia de caracteres de formato personalizado que use:Create a custom format string that uses:

    • O espaço reservado para zero “0” para cada um dos zeros à esquerda que aparecem na cadeia de caracteres.The zero placeholder "0" for each of the leading zeros to appear in the string.

    • O espaço reservado para zero ou o espaço reservado de dígito “#” para representar cada dígito na cadeia de caracteres padrão.Either the zero placeholder or the digit placeholder "#" to represent each digit in the default string.

  4. Forneça a cadeia de caracteres de formato personalizado como parâmetro para o método ToString(String) do número ou para um método que use a formatação composta.Supply the custom format string as a parameter either to the number's ToString(String) method or to a method that supports composite formatting.

O exemplo a seguir acrescenta dois valores Double com cinco dígitos zero à esquerda.The following example pads two Double values with five leading zeros.

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            

Consulte tambémSee also