Cómo: Rellenar un número con ceros inicialesHow to: Pad a Number with Leading Zeros

Si quiere agregar ceros a la izquierda de un entero, puede hacerlo mediante la cadena de formato numérico estándar "D" con un especificador de precisión.You can add leading zeros to an integer by using the "D" standard numeric format string with a precision specifier. Para agregar ceros a la izquierda tanto de enteros como de números de punto flotante, use una cadena de formato numérico personalizada.You can add leading zeros to both integer and floating-point numbers by using a custom numeric format string. En este artículo se explica cómo usar ambos métodos para rellenar un número con ceros a la izquierda.This article shows how to use both methods to pad a number with leading zeros.

Para rellenar un entero con ceros a la izquierda hasta una longitud concretaTo pad an integer with leading zeros to a specific length

  1. Determine el número mínimo de dígitos que desea que muestre el valor entero.Determine the minimum number of digits you want the integer value to display. Incluya los dígitos a la izquierda en este número.Include any leading digits in this number.

  2. Determine si desea mostrar el entero como valor decimal o hexadecimal.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Para mostrar el entero como valor decimal, llame a su método ToString(String) y pase la cadena "Dn" como valor del parámetro format, donde n representa la longitud mínima de la cadena.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 mostrar el entero como valor hexadecimal, llame a su método ToString(String) y pase la cadena "Xn" como valor del parámetro format, donde n representa la longitud mínima de la cadena.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.

También puede usar la cadena de formato en una cadena interpolada en ambos, C# y Visual Basic, o puede llamar a un método, como String.Format o Console.WriteLine, que usa formato compuesto.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.

En el ejemplo siguiente se aplica formato a varios valores enteros con ceros a la izquierda de modo que la longitud mínima total del número con formato sea de ocho 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 rellenar un entero con una determinada cantidad de ceros a la izquierdaTo pad an integer with a specific number of leading zeros

  1. Determine cuántos ceros a la izquierda desea que muestre el valor entero.Determine how many leading zeros you want the integer value to display.

  2. Determine si desea mostrar el entero como valor decimal o hexadecimal.Determine whether you want to display the integer as a decimal value or a hexadecimal value.

    • Para darle formato como valor decimal, se requiere que use el especificador de formato estándar "D".Formatting it as a decimal value requires that you use the "D" standard format specifier.

    • Para darle formato como valor hexadecimal, se requiere que use el especificador de formato estándar "X".Formatting it as a hexadecimal value requires that you use the "X" standard format specifier.

  3. Determine la longitud de la cadena numérica sin rellenar mediante una llamada a los métodos ToString("D").Length o ToString("X").Length del valor entero.Determine the length of the unpadded numeric string by calling the integer value's ToString("D").Length or ToString("X").Length method.

  4. Agregue el número de ceros a la izquierda que desea incluir en la cadena con formato a la longitud de la cadena numérica sin rellenar.Add the number of leading zeros that you want to include in the formatted string to the length of the unpadded numeric string. Al agregar el número de ceros iniciales se define la longitud total de la cadena rellenada.Adding the number of leading zeros defines the total length of the padded string.

  5. Llame al método ToString(String) del valor entero y pase la cadena "Dn" para cadenas decimales y "Xn" para cadenas hexadecimales, donde n representa la longitud total de la cadena rellenada.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. También puede usar la cadena de formato "Dn" o "Xn" en un método que admita formato compuesto.You can also use the "Dn" or "Xn" format string in a method that supports composite formatting.

En el ejemplo siguiente se rellena un valor entero con cinco ceros a la izquierda.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 rellenar un valor numérico con ceros a la izquierda hasta una longitud concretaTo pad a numeric value with leading zeros to a specific length

  1. Determine con cuántos dígitos a la izquierda del decimal desea que se represente la cadena del número.Determine how many digits to the left of the decimal you want the string representation of the number to have. Incluya los ceros a la izquierda en este número total de dígitos.Include any leading zeros in this total number of digits.

  2. Defina una cadena de formato numérico personalizado en la que se use el marcador de posición cero "0" para representar el número mínimo de ceros.Define a custom numeric format string that uses the zero placeholder "0" to represent the minimum number of zeros.

  3. Llame al método ToString(String) del número y pase la cadena de formato personalizado.Call the number's ToString(String) method and pass it the custom format string. También puede usar la cadena de formato personalizado con interpolación de cadena o con un método que admita formato compuesto.You can also use the custom format string with string interpolation or with a method that supports composite formatting.

En el ejemplo siguiente se da formato a varios valores numéricos con ceros iniciales.The following example formats several numeric values with leading zeros. Como resultado, la longitud total del número con formato es de al menos ocho dígitos a la izquierda del 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 rellenar un valor numérico con una determinada cantidad de ceros a la izquierdaTo pad a numeric value with a specific number of leading zeros

  1. Determine cuántos ceros a la izquierda desea que tenga el valor numérico.Determine how many leading zeros you want the numeric value to have.

  2. Determine el número de dígitos a la izquierda del separador decimal que tendrá la cadena numérica sin rellenar:Determine the number of digits to the left of the decimal in the unpadded numeric string:

    1. Determine si la representación de cadena de un número incluye un símbolo de separador decimal.Determine whether the string representation of a number includes a decimal point symbol.

    2. Si incluye un símbolo de separador decimal, determine el número de caracteres a la izquierda del separador decimal.If it does include a decimal point symbol, determine the number of characters to the left of the decimal point.

      o bien-or-

      Si no incluye un símbolo de separador decimal, determine la longitud de la cadena.If it doesn't include a decimal point symbol, determine the string's length.

  3. Cree una cadena de formato personalizado que utilice:Create a custom format string that uses:

    • El marcador de posición cero "0" para cada uno de los ceros a la izquierda que aparecen en la cadena.The zero placeholder "0" for each of the leading zeros to appear in the string.

    • El marcador de posición cero o el marcador de posición de dígito "#" para representar cada dígito en la cadena predeterminada.Either the zero placeholder or the digit placeholder "#" to represent each digit in the default string.

  4. Proporcione la cadena de formato personalizado como un parámetro bien al método ToString(String) del número, bien a un método que admita el formato compuesto.Supply the custom format string as a parameter either to the number's ToString(String) method or to a method that supports composite formatting.

En el ejemplo siguiente se rellenan dos valores Double con cinco ceros a la izquierda.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            

Vea tambiénSee also