Cadenas con formato numérico estándarStandard Numeric Format Strings

Las cadenas de formato numérico estándar se utilizan para dar formato a tipos numéricos comunes.Standard numeric format strings are used to format common numeric types. La forma de una cadena de formato numérico estándar es Axx, donde:A standard numeric format string takes the form Axx, where:

  • A es un carácter alfabético único denominado especificador de formato.A is a single alphabetic character called the format specifier. Cualquier cadena de formato numérico que contenga más de un carácter alfabético, incluido el espacio en blanco, se interpreta como una cadena de formato numérico personalizado.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Para obtener más información, consulte Cadenas con formato numérico personalizado.For more information, see Custom Numeric Format Strings.

  • xx es un entero opcional denominado especificador de precisión.xx is an optional integer called the precision specifier. El especificador de precisión está comprendido entre el 0 y el 99 y afecta al número de dígitos del resultado.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. Observe que el especificador de precisión controla el número de dígitos en la representación de cadena de un número.Note that the precision specifier controls the number of digits in the string representation of a number. No redondea el número en sí.It does not round the number itself. Para realizar una operación de redondeo, use el método Math.Ceiling, Math.Floor o Math.Round.To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    Cuando el especificador de precisión controla el número de dígitos fraccionarios de la cadena de resultado, esta refleja un número redondeado al resultado representable más cercano al resultado de precisión infinita.When precision specifier controls the number of fractional digits in the result string, the result string reflects a number that is rounded to a representable result nearest to the infinitely precise result. En el caso de que haya dos resultados representables igualmente cercanos:If there are two equally near representable results:

    • En .NET Framework y .NET Core (hasta la versión 2.0) , el runtime selecciona el resultado con el dígito menos significativo más elevado (es decir, usando MidpointRounding.AwayFromZero).On the .NET Framework and .NET Core up to .NET Core 2.0, the runtime selects the result with the greater least significant digit (that is, using MidpointRounding.AwayFromZero).
    • En .NET Core 2.1 y versiones posteriores, el runtime selecciona el resultado con un dígito menos significativo par (es decir, usando MidpointRounding.ToEven).On .NET Core 2.1 and later, the runtime selects the result with an even least significant digit (that is, using MidpointRounding.ToEven).

    Nota

    El especificador de precisión determina el número de dígitos de la cadena de resultado.The precision specifier determines the number of digits in the result string. Para rellenar una cadena de resultado con espacios iniciales o finales, use la característica formatos compuestos y defina un componente de alineación en el elemento de formato.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

Las cadenas con formato numérico estándar son compatibles con:Standard numeric format strings are supported by:

Sugerencia

Puede descargar la Utilidad de formato, que es una aplicación que permite aplicar cadenas de formato a valores numéricos o de fecha y hora, y que muestra la cadena de resultado.You can download the Formatting Utility, an application that enables you to apply format strings to either numeric or date and time values and displays the result string.

En la tabla siguiente se describen los especificadores de formato numérico estándar y se muestran los resultados de ejemplo generados por cada especificador de formato.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. Consulte la sección Notas para obtener información adicional sobre cómo usar las cadenas con formato numérico estándar y la sección Ejemplo para ver una ilustración completa de su uso.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

Especificador de formatoFormat specifier nombreName DescripciónDescription EjemplosExamples
"C" o "c""C" or "c" MonedaCurrency Resultado: un valor de divisa.Result: A currency value.

Compatible con: todos los tipos numéricos.Supported by: All numeric types.

Especificador de precisión: número de dígitos decimales.Precision specifier: Number of decimal digits.

Especificador de precisión predeterminado: Definido por NumberFormatInfo.CurrencyDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Más información: Especificador de formato de divisa ("C").More information: The Currency ("C") Format Specifier.
123.456 ("C", en-US) -> $123.46123.456 ("C", en-US) -> $123.46

123.456 ("C", fr-FR) -> 123,46 €123.456 ("C", fr-FR) -> 123,46 €

123.456 ("C", ja-JP) -> ¥123123.456 ("C", ja-JP) -> ¥123

-123.456 ("C3", en-US) -> ($123.456)-123.456 ("C3", en-US) -> ($123.456)

-123.456 ("C3", fr-FR) -> -123,456 €-123.456 ("C3", fr-FR) -> -123,456 €

-123.456 ("C3", ja-JP) -> -¥123.456-123.456 ("C3", ja-JP) -> -¥123.456
"D" o "d""D" or "d" DecimalDecimal Resultado: dígitos enteros con signo negativo opcional.Result: Integer digits with optional negative sign.

Compatible con: solo tipos enteros.Supported by: Integral types only.

Especificador de precisión: número mínimo de dígitos.Precision specifier: Minimum number of digits.

Especificador de precisión predeterminado: número mínimo de dígitos necesario.Default precision specifier: Minimum number of digits required.

Más información: Especificador de formato decimal ("D").More information: The Decimal("D") Format Specifier.
1234 ("D") -> 12341234 ("D") -> 1234

-1234 ("D6") -> -001234-1234 ("D6") -> -001234
"E" o "e""E" or "e" Exponencial (científico)Exponential (scientific) Resultado: notación exponencial.Result: Exponential notation.

Compatible con: todos los tipos numéricos.Supported by: All numeric types.

Especificador de precisión: número de dígitos decimales.Precision specifier: Number of decimal digits.

Especificador de precisión predeterminado: 6.Default precision specifier: 6.

Más información: Especificador de formato exponencial ("E").More information: The Exponential ("E") Format Specifier.
1052.0329112756 ("E", en-US) -> 1.052033E+0031052.0329112756 ("E", en-US) -> 1.052033E+003

1052.0329112756 ("e", fr-FR) -> 1,052033e+0031052.0329112756 ("e", fr-FR) -> 1,052033e+003

-1052.0329112756 ("e2", en-US) -> -1.05e+003-1052.0329112756 ("e2", en-US) -> -1.05e+003

-1052.0329112756 ("E2", fr-FR) -> -1,05E+003-1052.0329112756 ("E2", fr-FR) -> -1,05E+003
"F" o "f""F" or "f" Punto fijoFixed-point Resultado: dígitos integrales y decimales con signo negativo opcional.Result: Integral and decimal digits with optional negative sign.

Compatible con: todos los tipos numéricos.Supported by: All numeric types.

Especificador de precisión: número de dígitos decimales.Precision specifier: Number of decimal digits.

Especificador de precisión predeterminado: Definido por NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Más información: Especificador de formato de punto fijo ("F").More information: The Fixed-Point ("F") Format Specifier.
1234.567 ("F", en-US) -> 1234.571234.567 ("F", en-US) -> 1234.57

1234.567 ("F", de-DE) -> 1234,571234.567 ("F", de-DE) -> 1234,57

1234 ("F1", en-US) -> 1234.01234 ("F1", en-US) -> 1234.0

1234 ("F1", de-DE) -> 1234,01234 ("F1", de-DE) -> 1234,0

-1234.56 ("F4", en-US) -> -1234.5600-1234.56 ("F4", en-US) -> -1234.5600

-1234.56 ("F4", de-DE) -> -1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
"G" o "g""G" or "g" GeneralGeneral Resultado: notación de punto fijo o científica, la que sea más compacta.Result: The more compact of either fixed-point or scientific notation.

Compatible con: todos los tipos numéricos.Supported by: All numeric types.

Especificador de precisión: número de dígitos significativos.Precision specifier: Number of significant digits.

Especificador de precisión predeterminado: depende del tipo numérico.Default precision specifier: Depends on numeric type.

Más información: Especificador de formato general ("G").More information: The General ("G") Format Specifier.
-123.456 ("G", en-US) -> -123.456-123.456 ("G", en-US) -> -123.456

-123.456 ("G", sv-SE) -> -123,456-123.456 ("G", sv-SE) -> -123,456

123.4546 ("G4", en-US) -> 123.5123.4546 ("G4", en-US) -> 123.5

123.4546 ("G4", sv-SE) -> 123,5123.4546 ("G4", sv-SE) -> 123,5

-1.234567890e-25 ("G", en-US) -> -1.23456789E-25-1.234567890e-25 ("G", en-US) -> -1.23456789E-25

-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" o "n""N" or "n" númeroNumber Resultado: dígitos integrales y decimales, separadores de grupos y un separador decimal con signo negativo opcional.Result: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Compatible con: todos los tipos numéricos.Supported by: All numeric types.

Especificador de precisión: número deseado de decimales.Precision specifier: Desired number of decimal places.

Especificador de precisión predeterminado: Definido por NumberFormatInfo.NumberDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Más información: Especificador de formato numérico ("N").More information: The Numeric ("N") Format Specifier.
1234.567 ("N", en-US) -> 1,234.571234.567 ("N", en-US) -> 1,234.57

1234.567 ("N", ru-RU) -> 1 234,571234.567 ("N", ru-RU) -> 1 234,57

1234 ("N1", en-US) -> 1,234.01234 ("N1", en-US) -> 1,234.0

1234 ("N1", ru-RU) -> 1 234,01234 ("N1", ru-RU) -> 1 234,0

-1234.56 ("N3", en-US) -> -1,234.560-1234.56 ("N3", en-US) -> -1,234.560

-1234.56 ("N3", ru-RU) -> -1 234,560-1234.56 ("N3", ru-RU) -> -1 234,560
"P" o "p""P" or "p" PorcentajePercent Resultado: número multiplicado por 100 y mostrado con un símbolo de porcentaje.Result: Number multiplied by 100 and displayed with a percent symbol.

Compatible con: todos los tipos numéricos.Supported by: All numeric types.

Especificador de precisión: número deseado de decimales.Precision specifier: Desired number of decimal places.

Especificador de precisión predeterminado: Definido por NumberFormatInfo.PercentDecimalDigits.Default precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Más información: Especificador de formato de porcentaje ("P").More information: The Percent ("P") Format Specifier.
1 ("P", en-US) -> 100.00 %1 ("P", en-US) -> 100.00 %

1 ("P", fr-FR) -> 100,00 %1 ("P", fr-FR) -> 100,00 %

-0.39678 ("P1", en-US) -> -39.7 %-0.39678 ("P1", en-US) -> -39.7 %

-0.39678 ("P1", fr-FR) -> -39,7 %-0.39678 ("P1", fr-FR) -> -39,7 %
"R" o "r""R" or "r" Acción de ida y vueltaRound-trip Resultado: cadena que puede aplicar acciones de ida y vuelta (round-trip) a un número idéntico.Result: A string that can round-trip to an identical number.

Compatible con: Single, Double y BigInteger.Supported by: Single, Double, and BigInteger.

Nota: Se recomienda solo para el tipo BigInteger.Note: Recommended for the BigInteger type only. Para los tipos Double, use "G17"; para los tipos Single, use "G9".For Double types, use "G17"; for Single types, use "G9".
Especificador de precisión: ignorado.Precision specifier: Ignored.

Más información: Especificador de formato de operación de ida y vuelta ("R").More information: The Round-trip ("R") Format Specifier.
123456789.12345678 ("R") -> 123456789.12345678123456789.12345678 ("R") -> 123456789.12345678

-1234567890.12345678 ("R") -> -1234567890.1234567-1234567890.12345678 ("R") -> -1234567890.1234567
"X" o "x""X" or "x" HexadecimalHexadecimal Resultado: cadena hexadecimal.Result: A hexadecimal string.

Compatible con: solo tipos enteros.Supported by: Integral types only.

Especificador de precisión: número de dígitos en la cadena de resultado.Precision specifier: Number of digits in the result string.

Más información: Especificador de formato hexadecimal ("X").More information: The HexaDecimal ("X") Format Specifier.
255 ("X") -> FF255 ("X") -> FF

-1 ("x") -> ff-1 ("x") -> ff

255 ("x4") -> 00ff255 ("x4") -> 00ff

-1 ("X4") -> 00FF-1 ("X4") -> 00FF
Cualquier otro carácter únicoAny other single character Especificador desconocidoUnknown specifier Resultado: produce FormatException en tiempo de ejecución.Result: Throws a FormatException at run time.

Usar cadenas de formato numérico estándarUsing Standard Numeric Format Strings

Nota

Los ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET.The C# examples in this article run in the Try.NET inline code runner and playground. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva.Select the Run button to run an example in an interactive window. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar.Once you execute the code, you can modify it and run the modified code by selecting Run again. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Una cadena de formato numérico estándar se puede usar para definir el formato de un valor numérico de una de dos maneras:A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • Se puede pasar a una sobrecarga del método ToString que tiene un parámetro format.It can be passed to an overload of the ToString method that has a format parameter. En el ejemplo siguiente se da formato a un valor numérico como una cadena de divisa en la referencia cultural actual (en este caso, en-US).The following example formats a numeric value as a currency string in the current culture (in this case, the en-US culture).

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    decimal value = 123.456m;
    Console.WriteLine(value.ToString("C2"));
    // Displays $123.46
    
    Dim value As Decimal = 123.456d
    Console.WriteLine(value.ToString("C2"))         
    ' Displays $123.46
    
  • Se puede proporcionar como el argumento formatString de un elemento de formato usado con métodos como String.Format, Console.WriteLine y StringBuilder.AppendFormat.It can be supplied as the formatString argument in a format item used with such methods as String.Format, Console.WriteLine, and StringBuilder.AppendFormat. Para obtener más información, consulte Formatos compuestos.For more information, see Composite Formatting. En el ejemplo siguiente se usa un elemento de formato para insertar un valor de divisa en una cadena.The following example uses a format item to insert a currency value in a string.

    Decimal value = static_cast<Decimal>(123.456);
    Console::WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    decimal value = 123.456m;
    Console.WriteLine("Your account balance is {0:C2}.", value);
    // Displays "Your account balance is $123.46."
    
    Dim value As Decimal = 123.456d
    Console.WriteLine("Your account balance is {0:C2}.", value)
    ' Displays "Your account balance is $123.46."
    

    Opcionalmente, puede facilitar un argumento alignment para especificar el ancho del campo numérico y si su valor está alineado a izquierda o derecha.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. En el ejemplo siguiente se alinea a la izquierda un valor de moneda en un campo de 28 caracteres y se alinea a la derecha un valor de moneda en un campo de 14 caracteres.The following example left-aligns a currency value in a 28-character field, and it right-aligns a currency value in a 14-character field.

    array<Decimal>^ amounts = { static_cast<Decimal>(16305.32), 
                                static_cast<Decimal>(18794.16) };
    Console::WriteLine("   Beginning Balance           Ending Balance");
    Console::WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    decimal[] amounts = { 16305.32m, 18794.16m };
    Console.WriteLine("   Beginning Balance           Ending Balance");
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts[0], amounts[1]);
    // Displays:
    //        Beginning Balance           Ending Balance
    //        $16,305.32                      $18,794.16      
    
    Dim amounts() As Decimal = { 16305.32d, 18794.16d }
    Console.WriteLine("   Beginning Balance           Ending Balance")
    Console.WriteLine("   {0,-28:C2}{1,14:C2}", amounts(0), amounts(1))
    ' Displays:
    '        Beginning Balance           Ending Balance
    '        $16,305.32                      $18,794.16      
    
  • Se puede proporcionar como el argumento formatString en un elemento de la expresión interpolada de una cadena interpolada.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Para más información, vea el tema $ (Referencia de C#) en la referencia de C# o el tema Interpolated Strings (Visual Basic Reference) [Cadenas interpoladas (Referencia de Visual Basic)] en la referencia de Visual Basic.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

En las secciones siguientes se proporciona información detallada sobre cada una de las cadenas de formato numérico estándar.The following sections provide detailed information about each of the standard numeric format strings.

Especificador de formato de divisa ("C")The Currency ("C") Format Specifier

El especificador de formato "C" (divisa) convierte un número en una cadena que representa una cantidad de divisa.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. El especificador de precisión indica el número deseado de posiciones decimales en la cadena de resultado.The precision specifier indicates the desired number of decimal places in the result string. Si se omite el especificador de precisión, la precisión predeterminada está definida por la propiedad NumberFormatInfo.CurrencyDecimalDigits.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

Si el valor al que se va a dar formato tiene más posiciones decimales que el número especificado o predeterminado, el valor fraccionario se redondea en la cadena de resultado.If the value to be formatted has more than the specified or default number of decimal places, the fractional value is rounded in the result string. Si el valor situado a la derecha del número de posiciones decimales especificadas es 5 o superior, el último dígito de la cadena de resultado se redondea desde cero.If the value to the right of the number of specified decimal places is 5 or greater, the last digit in the result string is rounded away from zero.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena devuelta.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
CurrencyPositivePattern Define la posición del símbolo de divisa para los valores positivos.Defines the placement of the currency symbol for positive values.
CurrencyNegativePattern Define la posición del símbolo de divisa para los valores negativos y especifica si el signo negativo está representado por paréntesis o por la propiedad NegativeSign.Defines the placement of the currency symbol for negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NegativeSign Define el signo negativo usado si CurrencyNegativePattern indica que no se emplean paréntesis.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Define el símbolo de divisa.Defines the currency symbol.
CurrencyDecimalDigits Define el número predeterminado de dígitos decimales en un valor de divisa.Defines the default number of decimal digits in a currency value. Este valor puede reemplazarse por el uso del especificador de precisión.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Define la cadena que separa los dígitos integrales y decimales.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Define la cadena que separa los grupos de números integrales.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Define el número de dígitos enteros que aparecen en un grupo.Defines the number of integer digits that appear in a group.

En el ejemplo siguiente se da formato a un valor Double con el especificador de formato de divisa.The following example formats a Double value with the currency format specifier.

double value = 12345.6789;
Console::WriteLine(value.ToString("C", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", CultureInfo::CurrentCulture));

Console::WriteLine(value.ToString("C3", 
                  CultureInfo::CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       kr 12.345,679
double value = 12345.6789;
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture));

Console.WriteLine(value.ToString("C3", 
                  CultureInfo.CreateSpecificCulture("da-DK")));
// The example displays the following output on a system whose
// current culture is English (United States):
//       $12,345.68
//       $12,345.679
//       12.345,679 kr
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("C", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", CultureInfo.CurrentCulture))

Console.WriteLine(value.ToString("C3", _
                  CultureInfo.CreateSpecificCulture("da-DK")))
' The example displays the following output on a system whose
' current culture is English (United States):
'       $12,345.68
'       $12,345.679
'       kr 12.345,679

Volver a la tablaBack to table

Especificador de formato decimal ("D")The Decimal ("D") Format Specifier

El especificador de formato "D" (o decimal) convierte un número en una cadena de dígitos decimales (0-9), precedida por un signo menos si el número es negativo.The "D" (or decimal) format specifier converts a number to a string of decimal digits (0-9), prefixed by a minus sign if the number is negative. Este formato sólo es compatible con los tipos enteros.This format is supported only for integral types.

El especificador de precisión indica el número mínimo de dígitos deseado en la cadena resultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Si es preciso, el número se rellena con ceros a la izquierda para generar el número de dígitos que aporta el especificador de precisión.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. Si no se indica ningún especificador de precisión, el valor predeterminado es el valor mínimo necesario para representar el entero sin ceros iniciales.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. Como se muestra en la tabla siguiente, una única propiedad afecta al formato de la cadena de resultado.As the following table shows, a single property affects the formatting of the result string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
NegativeSign Define la cadena que indica que un número es negativo.Defines the string that indicates that a number is negative.

En el ejemplo siguiente se da formato a un valor Int32 con el especificador de formato decimal.The following example formats an Int32 value with the decimal format specifier.

int value; 

value = 12345;
Console::WriteLine(value.ToString("D"));
// Displays 12345
Console::WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console::WriteLine(value.ToString("D"));
// Displays -12345
Console::WriteLine(value.ToString("D8"));
// Displays -00012345
int value; 

value = 12345;
Console.WriteLine(value.ToString("D"));
// Displays 12345
Console.WriteLine(value.ToString("D8"));
// Displays 00012345

value = -12345;
Console.WriteLine(value.ToString("D"));
// Displays -12345
Console.WriteLine(value.ToString("D8"));
// Displays -00012345
Dim value As Integer 

value = 12345
Console.WriteLine(value.ToString("D"))
' Displays 12345   
Console.WriteLine(value.ToString("D8"))
' Displays 00012345

value = -12345
Console.WriteLine(value.ToString("D"))
' Displays -12345
Console.WriteLine(value.ToString("D8"))
' Displays -00012345

Volver a la tablaBack to table

Especificador de formato exponencial ("E")The Exponential ("E") Format Specifier

El especificador de formato exponencial ("E") convierte un número en una cadena con el formato "-d.ddd…E+ddd" o "-d.ddd…e+ddd", donde cada "d" indica un dígito (0-9).The exponential ("E") format specifier converts a number to a string of the form "-d.ddd…E+ddd" or "-d.ddd…e+ddd", where each "d" indicates a digit (0-9). La cadena comienza con un signo menos si el número es negativo.The string starts with a minus sign if the number is negative. El separador decimal siempre va precedido por exactamente un dígito.Exactly one digit always precedes the decimal point.

El especificador de precisión indica el número deseado de dígitos después del separador decimal.The precision specifier indicates the desired number of digits after the decimal point. Si se omite el especificador de precisión, se emplea uno predeterminado que tiene seis dígitos después del separador decimal.If the precision specifier is omitted, a default of six digits after the decimal point is used.

El modelo de mayúsculas o minúsculas del especificador de formato indica si se debe prefijar el exponente con una "E" o con una "e".The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". El exponente siempre consta de un signo más o menos y de un mínimo de tres dígitos.The exponent always consists of a plus or minus sign and a minimum of three digits. El exponente se rellena con ceros para adaptarlo a este mínimo, si es necesario.The exponent is padded with zeros to meet this minimum, if required.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena devuelta.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
NegativeSign Define la cadena que indica que un número es negativo tanto para el coeficiente como para el exponente.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Define la cadena que separa el dígito integral de los dígitos decimales en el coeficiente.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Define la cadena que indica que un exponente es positivo.Defines the string that indicates that an exponent is positive.

En el ejemplo siguiente se da formato a un valor Double con el especificador de formato exponencial.The following example formats a Double value with the exponential format specifier.

double value = 12345.6789;
Console::WriteLine(value.ToString("E", CultureInfo::InvariantCulture));
// Displays 1.234568E+004

Console::WriteLine(value.ToString("E10", CultureInfo::InvariantCulture));
// Displays 1.2345678900E+004

Console::WriteLine(value.ToString("e4", CultureInfo::InvariantCulture));
// Displays 1.2346e+004

Console::WriteLine(value.ToString("E", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
double value = 12345.6789;
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture));
// Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture));
// Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture));
// Displays 1.2346e+004

Console.WriteLine(value.ToString("E", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 1,234568E+004
Dim value As Double = 12345.6789
Console.WriteLine(value.ToString("E", CultureInfo.InvariantCulture))
' Displays 1.234568E+004

Console.WriteLine(value.ToString("E10", CultureInfo.InvariantCulture))
' Displays 1.2345678900E+004

Console.WriteLine(value.ToString("e4", CultureInfo.InvariantCulture))
' Displays 1.2346e+004

Console.WriteLine(value.ToString("E", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 1,234568E+004

Volver a la tablaBack to table

Especificador de formato de punto fijo ("F")The Fixed-Point ("F") Format Specifier

El especificador de formato de punto fijo ("F") convierte un número en una cadena con el formato "-ddd.ddd…", donde cada "d" indica un dígito (0-9).The fixed-point ("F") format specifier converts a number to a string of the form "-ddd.ddd…" where each "d" indicates a digit (0-9). La cadena comienza con un signo menos si el número es negativo.The string starts with a minus sign if the number is negative.

El especificador de precisión indica el número deseado de cifras decimales.The precision specifier indicates the desired number of decimal places. Si se omite el especificador de precisión, la propiedad NumberFormatInfo.NumberDecimalDigits actual proporciona la precisión numérica.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. En la tabla siguiente se enumeran las propiedades del objeto NumberFormatInfo que controlan el formato de la cadena de resultado.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
NegativeSign Define la cadena que indica que un número es negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales de los decimales.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Define el número predeterminado de dígitos decimales.Defines the default number of decimal digits. Este valor puede reemplazarse por el uso del especificador de precisión.This value can be overridden by using the precision specifier.

En el ejemplo siguiente se da formato a un valor Double e Int32 con el especificador de formato de punto fijo.The following example formats a Double and an Int32 value with the fixed-point format specifier.

int integerNumber;
integerNumber = 17843;
Console::WriteLine(integerNumber.ToString("F", 
                  CultureInfo::InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console::WriteLine(integerNumber.ToString("F3", 
                  CultureInfo::InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console::WriteLine(doubleNumber.ToString("F", CultureInfo::InvariantCulture));
// Displays 18934.19

Console::WriteLine(doubleNumber.ToString("F0", CultureInfo::InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console::WriteLine(doubleNumber.ToString("F1", CultureInfo::InvariantCulture));  
// Displays -1898300.2

Console::WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo::CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
int integerNumber;
integerNumber = 17843;
Console.WriteLine(integerNumber.ToString("F", 
                  CultureInfo.InvariantCulture));
// Displays 17843.00

integerNumber = -29541;
Console.WriteLine(integerNumber.ToString("F3", 
                  CultureInfo.InvariantCulture));
// Displays -29541.000

double doubleNumber;
doubleNumber = 18934.1879;
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture));
// Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture));
// Displays 18934

doubleNumber = -1898300.1987;
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture));  
// Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", 
                  CultureInfo.CreateSpecificCulture("es-ES")));
// Displays -1898300,199                        
Dim integerNumber As Integer
integerNumber = 17843
Console.WriteLine(integerNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 17843.00

integerNumber = -29541
Console.WriteLine(integerNumber.ToString("F3", CultureInfo.InvariantCulture))
' Displays -29541.000

Dim doubleNumber As Double
doubleNumber = 18934.1879
Console.WriteLine(doubleNumber.ToString("F", CultureInfo.InvariantCulture))
' Displays 18934.19

Console.WriteLine(doubleNumber.ToString("F0", CultureInfo.InvariantCulture))
' Displays 18934

doubleNumber = -1898300.1987
Console.WriteLine(doubleNumber.ToString("F1", CultureInfo.InvariantCulture))  
' Displays -1898300.2

Console.WriteLine(doubleNumber.ToString("F3", _ 
                  CultureInfo.CreateSpecificCulture("es-ES")))
' Displays -1898300,199                        

Volver a la tablaBack to table

Especificador de formato general ("G")The General ("G") Format Specifier

El especificador de formato general ("G") convierte un número a la notación de punto fijo o científica más compacta, dependiendo del tipo del número y de si hay un especificador de precisión o no.The general ("G") format specifier converts a number to the more compact of either fixed-point or scientific notation, depending on the type of the number and whether a precision specifier is present. El especificador de precisión define el número máximo de dígitos significativos que pueden aparecer en la cadena de resultado.The precision specifier defines the maximum number of significant digits that can appear in the result string. Si el especificador de precisión se omite o es cero, el tipo del número determina la precisión predeterminada, como se indica en la tabla siguiente.If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Tipo numéricoNumeric type Precisión predeterminadaDefault precision
Byte o SByteByte or SByte 3 dígitos3 digits
Int16 o UInt16Int16 or UInt16 5 dígitos5 digits
Int32 o UInt32Int32 or UInt32 10 dígitos10 digits
Int64 19 dígitos19 digits
UInt64 20 dígitos20 digits
BigInteger Sin límite (igual que "R")Unlimited (same as "R")
Single 7 dígitos7 digits
Double 15 dígitos15 digits
Decimal 29 dígitos29 digits

La notación de punto fijo se utiliza si el exponente que resultaría de la expresión del número en notación científica es mayor que -5 y menor que el especificador de precisión, de lo contrario se utiliza la notación científica.Fixed-point notation is used if the exponent that would result from expressing the number in scientific notation is greater than -5 and less than the precision specifier; otherwise, scientific notation is used. El resultado contiene un separador decimal si es necesario y se omiten los ceros finales después de ese separador.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. Si el especificador de precisión está presente y el número de dígitos significativos del resultado supera la precisión especificada, los dígitos finales sobrantes se quitan mediante redondeo.If the precision specifier is present and the number of significant digits in the result exceeds the specified precision, the excess trailing digits are removed by rounding.

Sin embargo, si el número es Decimal y se omite el especificador de precisión, siempre se usa la notación de punto fijo y se conservan los ceros finales.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

Si se usa la notación científica, el exponente del resultado lleva el prefijo "E" si el especificador de formato es "G", o "e" si el especificador de formato es "g".If scientific notation is used, the exponent in the result is prefixed with "E" if the format specifier is "G", or "e" if the format specifier is "g". El exponente contiene un mínimo de dos dígitos.The exponent contains a minimum of two digits. Esto difiere del formato para la notación científica que genera el especificador de formato exponencial, que incluye un mínimo de tres dígitos en el exponente.This differs from the format for scientific notation that is produced by the exponential format specifier, which includes a minimum of three digits in the exponent.

Tenga en cuenta que, cuando se usa con un valor Double, el especificador de formato "G17" garantiza que el valor Double original realice un recorrido de ida y vuelta correctamente.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. Esto se debe a que Double es un número de punto flotante de doble precisión compatible con IEEE 754-2008 (binary64) que ofrece un máximo de 17 dígitos de precisión significativos.This is because Double is an IEEE 754-2008-compliant double-precision (binary64) floating point number that gives up to 17 significant digits of precision. Se recomienda su uso en lugar del especificador de formato "R", ya que, en algunos casos, "R" no logra realizar un recorrido de ida y vuelta correcto por los valores de números de punto flotante de doble precisión.We recommend its use instead of the "R" format specifier, since in some cases "R" fails to successfully round-trip double-precision floating point values. Esto se ilustra en el siguiente ejemplo.The following example illustrates one such case.

double original = 0.84551240822557006;
var rSpecifier = original.ToString("R");
var g17Specifier = original.ToString("G17");

var rValue = Double.Parse(rSpecifier);
var g17Value = Double.Parse(g17Specifier);

Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}");
Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}");
// The example displays the following output:
//     0.84551240822557006 = 0.84551240822557: False
//     0.84551240822557006 = 0.84551240822557006: True
Module Example
   Public Sub Main()
      Dim original As Double = 0.84551240822557006
      Dim rSpecifier = original.ToString("R")
      Dim g17Specifier = original.ToString("G17")
      
      Dim rValue = Double.Parse(rSpecifier)
      Dim g17Value = Double.Parse(g17Specifier)
      
      Console.WriteLine($"{original:G17} = {rSpecifier} (R): {original.Equals(rValue)}")
      Console.WriteLine($"{original:G17} = {g17Specifier} (G17): {original.Equals(g17Value)}")
   End Sub
End Module
' The example displays the following output:
'     0.84551240822557006 = 0.84551240822557 (R): False
'     0.84551240822557006 = 0.84551240822557006 (G17): True
  

Cuando se usa con un valor Single, el especificador de formato "G9" garantiza que el valor Single original realice un recorrido de ida y vuelta correctamente.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. Esto se debe a que Single es un número de punto flotante de precisión sencilla compatible con IEEE 754-2008 (binary32) que ofrece hasta nueve dígitos de precisión significativos.This is because Single is an IEEE 754-2008-compliant single-precision (binary32) floating point number that gives up to nine significant digits of precision. Por motivos de rendimiento, se recomienda su uso en lugar del especificador de formato "R".For performance reasons, we recommend its use instead of the "R" format specifier.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena de resultado.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
NegativeSign Define la cadena que indica que un número es negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales de los decimales.Defines the string that separates integral digits from decimal digits.
PositiveSign Define la cadena que indica que un exponente es positivo.Defines the string that indicates that an exponent is positive.

En el ejemplo siguiente se da formato a valores de punto flotante ordenados con el especificador de formato general.The following example formats assorted floating-point values with the general format specifier.

double number;

number = 12345.6789;      
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays  12345.6789
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console::WriteLine(number.ToString("G7", CultureInfo::InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 2.3E-06       
Console::WriteLine(number.ToString("G", 
                  CultureInfo::CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console::WriteLine(number.ToString("G", CultureInfo::InvariantCulture));
// Displays 0.0023

number = 1234;
Console::WriteLine(number.ToString("G2", CultureInfo::InvariantCulture));
// Displays 1.2E+03

number = Math::PI;
Console::WriteLine(number.ToString("G5", CultureInfo::InvariantCulture));
// Displays 3.1416    
double number;

number = 12345.6789;      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays  12345.6789
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 12345,6789
                        
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture));
// Displays 12345.68 

number = .0000023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 2.3E-06       
Console.WriteLine(number.ToString("G", 
                  CultureInfo.CreateSpecificCulture("fr-FR")));
// Displays 2,3E-06

number = .0023;
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture));
// Displays 0.0023

number = 1234;
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture));
// Displays 1.2E+03

number = Math.PI;
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture));
// Displays 3.1416    
Dim number As Double

number = 12345.6789      
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays  12345.6789
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 12345,6789
                        
Console.WriteLine(number.ToString("G7", CultureInfo.InvariantCulture))
' Displays 12345.68 

number = .0000023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 2.3E-06       
Console.WriteLine(number.ToString("G", _
                  CultureInfo.CreateSpecificCulture("fr-FR")))
' Displays 2,3E-06

number = .0023
Console.WriteLine(number.ToString("G", CultureInfo.InvariantCulture))
' Displays 0.0023

number = 1234
Console.WriteLine(number.ToString("G2", CultureInfo.InvariantCulture))
' Displays 1.2E+03

number = Math.Pi
Console.WriteLine(number.ToString("G5", CultureInfo.InvariantCulture))
' Displays 3.1416    

Volver a la tablaBack to table

Especificador de formato numérico ("N")The Numeric ("N") Format Specifier

El especificador de formato numérico ("N") convierte un número en una cadena con el formato "-d,ddd,ddd.ddd…", donde "-" indica el símbolo de número negativo, si es necesario; "d", representa cada dígito (0-9); "," es el separador de grupo; y "." es el símbolo de punto decimal.The numeric ("N") format specifier converts a number to a string of the form "-d,ddd,ddd.ddd…", where "-" indicates a negative number symbol if required, "d" indicates a digit (0-9), "," indicates a group separator, and "." indicates a decimal point symbol. El especificador de precisión indica el número deseado de dígitos después del separador decimal.The precision specifier indicates the desired number of digits after the decimal point. Si se omite el especificador de precisión, el número de posiciones decimales está definido por la propiedad NumberFormatInfo.NumberDecimalDigits actual.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena de resultado.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
NegativeSign Define la cadena que indica que un número es negativo.Defines the string that indicates that a number is negative.
NumberNegativePattern Define el formato de los valores negativos y especifica si el signo negativo se representa mediante paréntesis o por la propiedad NegativeSign.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Define el número de dígitos enteros que aparecen entre los separadores de grupos.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Define la cadena que separa los grupos de números integrales.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales y decimales.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Define el número predeterminado de dígitos decimales.Defines the default number of decimal digits. Este valor puede reemplazarse por el uso de un especificador de precisión.This value can be overridden by using a precision specifier.

En el ejemplo siguiente se da formato a valores de punto flotante ordenados con el especificador de formato numérico.The following example formats assorted floating-point values with the number format specifier.

double dblValue = -12445.6789;
Console::WriteLine(dblValue.ToString("N", CultureInfo::InvariantCulture));
// Displays -12,445.68
Console::WriteLine(dblValue.ToString("N1", 
                  CultureInfo::CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console::WriteLine(intValue.ToString("N1", CultureInfo::InvariantCulture));
// Displays 123,456,789.0 
double dblValue = -12445.6789;
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture));
// Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", 
                  CultureInfo.CreateSpecificCulture("sv-SE")));
// Displays -12 445,7

int intValue = 123456789;
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture));
// Displays 123,456,789.0 
Dim dblValue As Double = -12445.6789
Console.WriteLine(dblValue.ToString("N", CultureInfo.InvariantCulture))
' Displays -12,445.68
Console.WriteLine(dblValue.ToString("N1", _
                  CultureInfo.CreateSpecificCulture("sv-SE")))
' Displays -12 445,7

Dim intValue As Integer = 123456789
Console.WriteLine(intValue.ToString("N1", CultureInfo.InvariantCulture))
' Displays 123,456,789.0 

Volver a la tablaBack to table

Especificador de formato de porcentaje ("P")The Percent ("P") Format Specifier

El especificador de formato de porcentaje ("P") multiplica un número por 100 y lo convierte en una cadena que representa un porcentaje.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. El especificador de precisión indica el número deseado de cifras decimales.The precision specifier indicates the desired number of decimal places. Si se omite el especificador de precisión, se usará la precisión numérica predeterminada proporcionada por la propiedad PercentDecimalDigits actual.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena devuelta.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
PercentPositivePattern Define la posición del símbolo de porcentaje para los valores positivos.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Define la posición del símbolo de porcentaje y del símbolo negativo para los valores negativos.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Define la cadena que indica que un número es negativo.Defines the string that indicates that a number is negative.
PercentSymbol Define el símbolo de porcentaje.Defines the percent symbol.
PercentDecimalDigits Define el número predeterminado de dígitos decimales en un valor de porcentaje.Defines the default number of decimal digits in a percentage value. Este valor puede reemplazarse por el uso del especificador de precisión.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Define la cadena que separa los dígitos integrales y decimales.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Define la cadena que separa los grupos de números integrales.Defines the string that separates groups of integral numbers.
PercentGroupSizes Define el número de dígitos enteros que aparecen en un grupo.Defines the number of integer digits that appear in a group.

En el ejemplo siguiente se da formato a valores de punto flotante con el especificador de formato de porcentaje.The following example formats floating-point values with the percent format specifier.

double number = .2468013;
Console::WriteLine(number.ToString("P", CultureInfo::InvariantCulture));
// Displays 24.68 %
Console::WriteLine(number.ToString("P", 
                  CultureInfo::CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console::WriteLine(number.ToString("P1", CultureInfo::InvariantCulture));
// Displays 24.7 %
double number = .2468013;
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture));
// Displays 24.68 %
Console.WriteLine(number.ToString("P", 
                  CultureInfo.CreateSpecificCulture("hr-HR")));
// Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture));
// Displays 24.7 %
Dim number As Double = .2468013
Console.WriteLine(number.ToString("P", CultureInfo.InvariantCulture))
' Displays 24.68 %
Console.WriteLine(number.ToString("P", _
                  CultureInfo.CreateSpecificCulture("hr-HR")))
' Displays 24,68%     
Console.WriteLine(number.ToString("P1", CultureInfo.InvariantCulture))
' Displays 24.7 %

Volver a la tablaBack to table

Especificador de formato de operación de ida y vuelta ("R")The Round-trip ("R") Format Specifier

El especificador de formato de operación de ida y vuelta ("R") intenta garantizar que un valor numérico que se convierte en una cadena vuelva a tomar el mismo valor numérico.The round-trip ("R") format specifier attempts to ensure that a numeric value that is converted to a string is parsed back into the same numeric value. Este formato solo es compatible para los tipos Single, Double y BigInteger.This format is supported only for the Single, Double, and BigInteger types.

Para los valores Double, el especificador de formato "R", en algunos casos, no logra realizar un recorrido de ida y vuelta correcto por el valor original.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. Para los dos valores Double y Single, también ofrece un rendimiento relativamente bajo.For both Double and Single values, it also offers relatively poor performance. En su lugar, se recomienda usar el especificador de formato "G17" para los valores Double y el especificador de formato "G9" para realizar un recorrido de ida y vuelta correcto por los valores Single.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

Cuando se da formato a un valor BigInteger mediante este especificador, su representación de cadena contiene todos los dígitos significativos del valor BigInteger.When a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Aunque puede incluir un especificador de precisión, se omite.Although you can include a precision specifier, it is ignored. Los especificadores de ida y vuelta tienen prioridad sobre la precisión al utilizar este especificador.Round trips are given precedence over precision when using this specifier.
La información de formato del objeto NumberFormatInfo actual afecta a la cadena de resultado.The result string is affected by the formatting information of the current NumberFormatInfo object. En la tabla siguiente se enumeran las propiedades de NumberFormatInfo que controlan el formato de la cadena de resultado.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Propiedad de NumberFormatInfoNumberFormatInfo property DescripciónDescription
NegativeSign Define la cadena que indica que un número es negativo.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Define la cadena que separa los dígitos integrales de los decimales.Defines the string that separates integral digits from decimal digits.
PositiveSign Define la cadena que indica que un exponente es positivo.Defines the string that indicates that an exponent is positive.

En el ejemplo siguiente se da formato a un valor BigInteger con el especificador de formato de ida y vuelta.The following example formats a BigInteger value with the round-trip format specifier.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{ 
   BigInteger value = BigInteger::Pow(Int64::MaxValue, 2);
   Console::WriteLine(value.ToString("R"));
}
// The example displays the following output:
//      85070591730234615847396907784232501249  


using System;
using System.Numerics;

public class Example
{
   public static void Main()
   { 
      var value = BigInteger.Pow(Int64.MaxValue, 2);
      Console.WriteLine(value.ToString("R"));
   }
}                                                                                        // The example displays the following output:
//      85070591730234615847396907784232501249  


Imports System.Numerics

Module Example
   Public Sub Main()
      Dim value = BigInteger.Pow(Int64.MaxValue, 2)
      Console.WriteLine(value.ToString("R"))
   End Sub
End Module
' The example displays the following output:
'      85070591730234615847396907784232501249  

Importante

En algunos casos, los valores Double con el formato de cadena numérica estándar "R" no realizan correctamente la operación de ida y vuelta si se compilan usando los modificadores /platform:x64 o /platform:anycpu y se ejecutan en sistemas de 64 bits.In some cases, Double values formatted with the "R" standard numeric format string do not successfully round-trip if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems. Para más información, consulte el siguiente párrafo.See the following paragraph for more information.

Para solucionar el problema de los valores Double con formato de cadena numérico estándar “R” que no hacen correctamente el viaje de ida y vuelta si se compilan con conmutadores /platform:x64 o /platform:anycpu y se ejecutan en sistemas de 64 bits, puede dar formato a los valores Double usando la cadena de formato numérico estándar “G17”.To work around the problem of Double values formatted with the "R" standard numeric format string not successfully round-tripping if compiled using the /platform:x64 or /platform:anycpu switches and run on 64-bit systems., you can format Double values by using the "G17" standard numeric format string. En el ejemplo siguiente se usa la cadena de formato "R" con un valor Double que no realiza correctamente la operación de ida y vuelta, y usa también la cadena de formato "G17" para realizar correctamente la operación de ida y vuelta del valor original.The following example uses the "R" format string with a Double value that does not round-trip successfully, and also uses the "G17" format string to successfully round-trip the original value.

Console.WriteLine("Attempting to round-trip a Double with 'R':");
double initialValue = 0.6822871999174;
string valueString = initialValue.ToString("R",
                                           CultureInfo.InvariantCulture);
double roundTripped = double.Parse(valueString,
                                   CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped, initialValue.Equals(roundTripped));

Console.WriteLine("Attempting to round-trip a Double with 'G17':");
string valueString17 = initialValue.ToString("G17",
                                             CultureInfo.InvariantCulture);
double roundTripped17 = double.Parse(valueString17,
                                     CultureInfo.InvariantCulture);
Console.WriteLine("{0:R} = {1:R}: {2}\n",
                  initialValue, roundTripped17, initialValue.Equals(roundTripped17));
// If compiled to an application that targets anycpu or x64 and run on an x64 system,
// the example displays the following output:
//       Attempting to round-trip a Double with 'R':
//       0.6822871999174 = 0.68228719991740006: False
//
//       Attempting to round-trip a Double with 'G17':
//       0.6822871999174 = 0.6822871999174: True
Imports System.Globalization

Module Example
   Public Sub Main()
      Console.WriteLine("Attempting to round-trip a Double with 'R':")
      Dim initialValue As Double = 0.6822871999174
      Dim valueString As String = initialValue.ToString("R",
                                               CultureInfo.InvariantCulture)
      Dim roundTripped As Double = Double.Parse(valueString,
                                                CultureInfo.InvariantCulture)
      Console.WriteLine("{0:R} = {1:R}: {2}",
                        initialValue, roundTripped, initialValue.Equals(roundTripped))
      Console.WriteLine()
      
      Console.WriteLine("Attempting to round-trip a Double with 'G17':")
      Dim valueString17 As String = initialValue.ToString("G17",
                                                 CultureInfo.InvariantCulture)
      Dim roundTripped17 As Double = double.Parse(valueString17,
                                            CultureInfo.InvariantCulture)
      Console.WriteLine("{0:R} = {1:R}: {2}",
                        initialValue, roundTripped17, initialValue.Equals(roundTripped17))
   End Sub
End Module
' If compiled to an application that targets anycpu or x64 and run on an x64 system,
' the example displays the following output:
'       Attempting to round-trip a Double with 'R':
'       0.6822871999174 = 0.68228719991740006: False
'
'       Attempting to round-trip a Double with 'G17':
'       0.6822871999174 = 0.6822871999174: True

Volver a la tablaBack to table

Especificador de formato hexadecimal ("X")The Hexadecimal ("X") Format Specifier

El especificador de formato hexadecimal ("X") convierte un número en una cadena de dígitos hexadecimales.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. El modelo de mayúsculas y minúsculas del especificador de formato indica si se van a usar caracteres en mayúsculas o en minúsculas para los dígitos hexadecimales mayores de 9.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. Por ejemplo, use "X" para generar "ABCDEF" y "x" para generar "abcdef".For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Este formato sólo es compatible con los tipos enteros.This format is supported only for integral types.

El especificador de precisión indica el número mínimo de dígitos deseado en la cadena resultante.The precision specifier indicates the minimum number of digits desired in the resulting string. Si es preciso, el número se rellena con ceros a la izquierda para generar el número de dígitos que aporta el especificador de precisión.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

La información de formato del objeto NumberFormatInfo actual no afecta a la cadena de resultado.The result string is not affected by the formatting information of the current NumberFormatInfo object.

En el ejemplo siguiente se da formato a valores Int32 con el especificador de formato hexadecimal.The following example formats Int32 values with the hexadecimal format specifier.

int value; 

value = 0x2045e;
Console::WriteLine(value.ToString("x"));
// Displays 2045e
Console::WriteLine(value.ToString("X"));
// Displays 2045E
Console::WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console::WriteLine(value.ToString("X"));
// Displays 75BCD15
Console::WriteLine(value.ToString("X2"));
// Displays 75BCD15
int value; 

value = 0x2045e;
Console.WriteLine(value.ToString("x"));
// Displays 2045e
Console.WriteLine(value.ToString("X"));
// Displays 2045E
Console.WriteLine(value.ToString("X8"));
// Displays 0002045E

value = 123456789;
Console.WriteLine(value.ToString("X"));
// Displays 75BCD15
Console.WriteLine(value.ToString("X2"));
// Displays 75BCD15
Dim value As Integer 

value = &h2045e
Console.WriteLine(value.ToString("x"))
' Displays 2045e
Console.WriteLine(value.ToString("X"))
' Displays 2045E
Console.WriteLine(value.ToString("X8"))
' Displays 0002045E

value = 123456789
Console.WriteLine(value.ToString("X"))
' Displays 75BCD15
Console.WriteLine(value.ToString("X2"))
' Displays 75BCD15

Volver a la tablaBack to table

NotasNotes

Configuración del Panel de controlControl Panel Settings

Los valores de configuración del elemento Configuración regional y de idioma del Panel de control influyen en la cadena de resultado generada por una operación de formato.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. Esas configuraciones se usan para inicializar el objeto NumberFormatInfo asociado a la referencia cultural del subproceso actual, que proporciona valores que se usan para controlar el formato.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Los equipos que usan configuraciones diferentes generarán cadenas de resultado distintas.Computers that use different settings generate different result strings.

Asimismo, si se utiliza el constructor CultureInfo.CultureInfo(String) para crear instancias de un nuevo objeto CultureInfo que representa la misma referencia cultural que la referencia cultural del sistema actual, cualquier personalización establecida por el elemento Configuración regional y de idioma del Panel de control se aplicará al nuevo objeto CultureInfo.In addition, if the CultureInfo.CultureInfo(String) constructor is used to instantiate a new CultureInfo object that represents the same culture as the current system culture, any customizations established by the Regional and Language Options item in Control Panel will be applied to the new CultureInfo object. Puede usar el constructor CultureInfo.CultureInfo(String, Boolean) para crear un objeto CultureInfo que no refleje las personalizaciones de un sistema.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Propiedades NumberFormatInfoNumberFormatInfo Properties

El formato se ve influenciado por las propiedades del objeto NumberFormatInfo actual, proporcionado implícitamente por la referencia cultural del subproceso actual o explícitamente por el parámetro IFormatProvider del método que invoca el formato.Formatting is influenced by the properties of the current NumberFormatInfo object, which is provided implicitly by the current thread culture or explicitly by the IFormatProvider parameter of the method that invokes formatting. Especifique un objeto NumberFormatInfo o CultureInfo para dicho parámetro.Specify a NumberFormatInfo or CultureInfo object for that parameter.

Nota

Para obtener información sobre la personalización de patrones o cadenas que se usan para dar formato a valores numéricos, vea el tema de la clase NumberFormatInfo.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Tipos numéricos enteros y de punto flotanteIntegral and Floating-Point Numeric Types

Algunas descripciones de especificadores de formato numérico estándar hacen referencia a tipos numéricos enteros o de punto flotante.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. Los tipos numéricos integrales son Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64 y BigInteger.The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. Los tipos numéricos de punto flotante son Decimal, Single y Double.The floating-point numeric types are Decimal, Single, and Double.

Infinitos de punto flotante y NaNFloating-Point Infinities and NaN

Independientemente de la cadena de formato, si el valor de un tipo de punto flotante Single o Double es infinito positivo, infinito negativo o NaN (Not a Number, no es un número), la cadena con formato será el valor de la propiedad PositiveInfinitySymbol, NegativeInfinitySymbol o NaNSymbol respectiva especificada por el objeto NumberFormatInfo aplicable actualmente.Regardless of the format string, if the value of a Single or Double floating-point type is positive infinity, negative infinity, or not a number (NaN), the formatted string is the value of the respective PositiveInfinitySymbol, NegativeInfinitySymbol, or NaNSymbol property that is specified by the currently applicable NumberFormatInfo object.

EjemploExample

Nota

Algunos de los ejemplos de C# de este artículo se ejecutan en el ejecutor de código en línea y área de juegos de Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Haga clic en el botón Ejecutar para ejecutar un ejemplo en una ventana interactiva.Select the Run button to run an example in an interactive window. Una vez que se ejecuta el código, puede modificar y ejecutar el código modificado si vuelve a hacer clic en Ejecutar.Once you execute the code, you can modify it and run the modified code by selecting Run again. El código modificado se ejecuta en la ventana interactiva o, si se produce un error en la compilación, en la ventana interactiva se muestran todos los mensajes de error del compilador de C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

En el ejemplo siguiente se da formato a un valor numérico integral y de punto flotante mediante la referencia cultural en-US y todos los especificadores de formato numérico estándar.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. En este ejemplo se usan dos tipos numéricos concretos (Double y Int32), pero se obtendrían resultados similares con cualquiera de los demás tipos base numéricos (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal y Single).This example uses two particular numeric types (Double and Int32), but would yield similar results for any of the other numeric base types (Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, BigInteger, Decimal, and Single).

// Display string representations of numbers for en-us culture
CultureInfo ci = new CultureInfo("en-us");

// Output floating point values
double floating = 10761.937554;
Console.WriteLine("C: {0}", 
        floating.ToString("C", ci));           // Displays "C: $10,761.94"
Console.WriteLine("E: {0}", 
        floating.ToString("E03", ci));         // Displays "E: 1.076E+004"
Console.WriteLine("F: {0}", 
        floating.ToString("F04", ci));         // Displays "F: 10761.9376"         
Console.WriteLine("G: {0}",  
        floating.ToString("G", ci));           // Displays "G: 10761.937554"
Console.WriteLine("N: {0}", 
        floating.ToString("N03", ci));         // Displays "N: 10,761.938"
Console.WriteLine("P: {0}", 
        (floating/10000).ToString("P02", ci)); // Displays "P: 107.62 %"
Console.WriteLine("R: {0}", 
        floating.ToString("R", ci));           // Displays "R: 10761.937554"            
Console.WriteLine();

// Output integral values
int integral = 8395;
Console.WriteLine("C: {0}", 
        integral.ToString("C", ci));           // Displays "C: $8,395.00"
Console.WriteLine("D: {0}", 
        integral.ToString("D6", ci));          // Displays "D: 008395" 
Console.WriteLine("E: {0}", 
        integral.ToString("E03", ci));         // Displays "E: 8.395E+003"
Console.WriteLine("F: {0}", 
        integral.ToString("F01", ci));         // Displays "F: 8395.0"    
Console.WriteLine("G: {0}",  
        integral.ToString("G", ci));           // Displays "G: 8395"
Console.WriteLine("N: {0}", 
        integral.ToString("N01", ci));         // Displays "N: 8,395.0"
Console.WriteLine("P: {0}", 
        (integral/10000.0).ToString("P02", ci)); // Displays "P: 83.95 %"
Console.WriteLine("X: 0x{0}", 
        integral.ToString("X", ci));           // Displays "X: 0x20CB"
Console.WriteLine();
Option Strict On

Imports System.Globalization
Imports System.Threading

Module NumericFormats
   Public Sub Main()
      ' Display string representations of numbers for en-us culture
      Dim ci As New CultureInfo("en-us")
      
      ' Output floating point values
      Dim floating As Double = 10761.937554
      Console.WriteLine("C: {0}", _
              floating.ToString("C", ci))           ' Displays "C: $10,761.94"
      Console.WriteLine("E: {0}", _
              floating.ToString("E03", ci))         ' Displays "E: 1.076E+004"
      Console.WriteLine("F: {0}", _
              floating.ToString("F04", ci))         ' Displays "F: 10761.9376"         
      Console.WriteLine("G: {0}", _ 
              floating.ToString("G", ci))           ' Displays "G: 10761.937554"
      Console.WriteLine("N: {0}", _
              floating.ToString("N03", ci))         ' Displays "N: 10,761.938"
      Console.WriteLine("P: {0}", _
              (floating/10000).ToString("P02", ci)) ' Displays "P: 107.62 %"
      Console.WriteLine("R: {0}", _
              floating.ToString("R", ci))           ' Displays "R: 10761.937554"            
      Console.WriteLine()
      
      ' Output integral values
      Dim integral As Integer = 8395
      Console.WriteLine("C: {0}", _
              integral.ToString("C", ci))           ' Displays "C: $8,395.00"
      Console.WriteLine("D: {0}", _
              integral.ToString("D6"))              ' Displays "D: 008395" 
      Console.WriteLine("E: {0}", _
              integral.ToString("E03", ci))         ' Displays "E: 8.395E+003"
      Console.WriteLine("F: {0}", _
              integral.ToString("F01", ci))         ' Displays "F: 8395.0"    
      Console.WriteLine("G: {0}", _ 
              integral.ToString("G", ci))           ' Displays "G: 8395"
      Console.WriteLine("N: {0}", _
              integral.ToString("N01", ci))         ' Displays "N: 8,395.0"
      Console.WriteLine("P: {0}", _
              (integral/10000).ToString("P02", ci)) ' Displays "P: 83.95 %"
      Console.WriteLine("X: 0x{0}", _
              integral.ToString("X", ci))           ' Displays "X: 0x20CB"
      Console.WriteLine()
   End Sub
End Module

Vea tambiénSee also