Cómo: Rellenar un número con ceros iniciales

  • Artículo

Puede rellenar un entero con ceros iniciales si usa la cadena de formato numérico estándar "D" junto con un especificador de precisión. Puede rellenar tanto números enteros como números de punto flotante con ceros iniciales si usa una cadena de formato numérico personalizada. En este tema se muestra cómo usar ambos métodos para rellenar un número con ceros iniciales.

Para rellenar un entero con ceros iniciales hasta una longitud concreta

  1. Determine cuántos dígitos desea que muestre el valor entero. Incluya los dígitos iniciales en este número.

  2. Determine si desea mostrar el número entero como un valor decimal o como un valor hexadecimal.

    1. Para mostrar el entero como un valor decimal, llame a su método ToString(String) y pase la cadena "Dn" como el valor del parámetro format, donde n representa la longitud mínima de la cadena.

    2. Para mostrar el entero como un valor hexadecimal, llame a su método ToString(String) y pase la cadena "Xn" como el valor del parámetro format, donde n representa la longitud mínima de la cadena.

    También puede usar la cadena de formato en un método, como Format o WriteLine, que usa formato compuesto.

En el ejemplo siguiente se da formato a varios valores enteros con ceros iniciales de forma que la longitud total del número con formato sea al menos de ocho 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 rellenar un entero con un número concreto de ceros iniciales

  1. Determine cuántos ceros iniciales desea que muestre el valor entero.

  2. Determine si desea mostrar el número entero como un valor decimal o como un valor hexadecimal. Para darle formato como un valor decimal debe usar el especificador de formato estándar "D"; para darle formato como un valor hexadecimal hay que usar el especificador de formato estándar "X".

  3. Determine la longitud de una cadena numérica sin rellenar llamando al método ToString("D").Length o ToString("X").Length del valor entero.

  4. Sume el número de ceros iniciales que desea incluir en la cadena con formato a la longitud de la cadena numérica sin rellenar. Esto define la longitud total de la cadena rellena.

  5. Llame al método ToString(String) del valor entero y pase la cadena "Dn" para las cadenas decimales y "Xn" para las cadenas hexadecimales, donde n representa la longitud total de la cadena rellena. También puede usar la cadena de formato "Dn" o "Xn" en un método que admite formato compuesto.

En el ejemplo siguiente se rellena un valor entero con cinco ceros iniciales.

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 rellenar un valor numérico con ceros iniciales hasta una longitud concreta

  1. Determine cuántos dígitos a la izquierda del signo decimal desea que tenga la representación de cadena del número. Incluya los ceros iniciales en este número total de dígitos.

  2. Defina una cadena de formato numérico personalizada que use el marcador de posición cero ("0") para representar el número mínimo de ceros.

  3. Llame al método ToString(String) del número y pásele la cadena de formato personalizada. También puede usar la cadena de formato personalizada con un método que admita formato compuesto.

En el ejemplo siguiente se da formato a varios valores numéricos con ceros iniciales de manera que la longitud total del número con formato sea de al menos ocho dígitos a la izquierda del signo 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 rellenar un valor numérico con un número concreto de ceros iniciales

  1. Determine cuántos ceros iniciales desea que tenga el valor numérico.

  2. Determine el número de dígitos que hay a la izquierda del signo decimal en la cadena numérica sin rellenar. Para hacerlo:

    1. Determine si la representación de cadena de un número incluye un símbolo de separador decimal.

    2. Si incluye un símbolo de separador decimal, determine el número de caracteres que hay a la izquierda del separador decimal.

      O bien

      Si no lo incluye, determine la longitud de la cadena.

  3. Cree una cadena de formato personalizada que use el marcador de posición cero ("0") para cada uno de los ceros iniciales que aparecerá en la cadena y que use el marcador de posición cero o el marcador de posición de dígitos ("#") para representar cada dígito en la cadena predeterminada.

  4. Proporcione la cadena de formato personalizada como un parámetro al método ToString(String) del número o a un método que admita formato compuesto.

En el ejemplo siguiente se rellenan dos valores Double con cinco ceros iniciales.

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

Vea también

Conceptos

Cadenas con formato numérico personalizado

Cadenas con formato numérico estándar

Formatos compuestos