Standardní řetězce formátu číslaStandard Numeric Format Strings

Řetězce standardního číselného formátu se používají pro formátování běžných číselných typů.Standard numeric format strings are used to format common numeric types. Standardní číselný formátovací řetězec má formu Axx, kde:A standard numeric format string takes the form Axx, where:

  • Aje jeden abecední znak nazvaný specifikátor formátu.A is a single alphabetic character called the format specifier. Jakýkoli řetězec číselného formátu, který obsahuje více než jeden abecední znak, včetně prázdných znaků, je interpretován jako řetězec vlastního číselného formátu.Any numeric format string that contains more than one alphabetic character, including white space, is interpreted as a custom numeric format string. Další informace najdete v tématu vlastní číselné formátovací řetězce.For more information, see Custom Numeric Format Strings.

  • xxje volitelné celé číslo, které se nazývá specifikátor přesnosti.xx is an optional integer called the precision specifier. Specifikátor přesnosti má rozsah od 0 do 99 a má vliv na počet číslic ve výsledku.The precision specifier ranges from 0 to 99 and affects the number of digits in the result. Všimněte si, že specifikátor přesnosti určuje počet číslic v řetězcové reprezentaci čísla.Note that the precision specifier controls the number of digits in the string representation of a number. Neprovádí zaokrouhlení samotného čísla.It does not round the number itself. K provedení operace zaokrouhlení použijte Math.Ceilingmetodu, Math.Floornebo Math.Round .To perform a rounding operation, use the Math.Ceiling, Math.Floor, or Math.Round method.

    Pokud specifikátor přesnosti řídí počet zlomkových číslic ve výsledném řetězci, výsledný řetězec odráží číslo, které je zaokrouhleno na reprezentovatelné výsledky nejbližší nekonečně přesnému výsledku.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. Pokud existují dva stejně blízkoně dostupné výsledky:If there are two equally near representable results:

    • V .NET Framework a .NET Core až do .NET core 2,0vybírá modul runtime výsledek s větší nejméně významnou číslicí (tj. pomocí 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).
    • V .NET Core 2,1 a novějšímodul runtime vybírá výsledek s nejméně významnou číslicí (tj. pomocí 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).

    Poznámka

    Specifikátor přesnosti určuje počet číslic ve výsledném řetězci.The precision specifier determines the number of digits in the result string. Chcete-li doplnit výsledný řetězec pomocí počátečních nebo koncových mezer, použijte funkci složeného formátování a definujte součást zarovnání v položce formátu.To pad a result string with leading or trailing spaces, use the composite formatting feature and define an alignment component in the format item.

Standardní řetězce číselného formátu jsou podporovány v:Standard numeric format strings are supported by:

Tip

Můžete si stáhnout formátovací nástroj, aplikaci .net Core model Windows Forms, která umožňuje použití řetězců formátu na číselné hodnoty nebo hodnoty data a času a zobrazuje výsledný řetězec.You can download the Formatting Utility, a .NET Core Windows Forms application that lets you apply format strings to either numeric or date and time values and displays the result string. Zdrojový kód je k dispozici pro C# a Visual Basic.Source code is available for C# and Visual Basic.

Následující tabulka popisuje standardní specifikátory číselného formátu a zobrazuje vzorový výstup vyprodukovaný každým specifikátorem formátu.The following table describes the standard numeric format specifiers and displays sample output produced by each format specifier. Další informace o použití standardních číselných formátovacích řetězců naleznete v části poznámky a v části příklad pro komplexní ilustraci jejich použití.See the Notes section for additional information about using standard numeric format strings, and the Example section for a comprehensive illustration of their use.

Specifikátor formátuFormat specifier NameName PopisDescription PříkladyExamples
"C" nebo "c""C" or "c" MěnaCurrency Vyústit Hodnota měny.Result: A currency value.

Podporováno: Všechny číselné typy.Supported by: All numeric types.

Specifikátor přesnosti: Počet desetinných číslic.Precision specifier: Number of decimal digits.

Výchozí specifikátor přesnosti: NumberFormatInfo.CurrencyDecimalDigitsDefinováno.Default precision specifier: Defined by NumberFormatInfo.CurrencyDecimalDigits.

Další informace: Specifikátor formátu měny ("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" nebo "d""D" or "d" Desetinné čísloDecimal Vyústit Celočíselné číslice s volitelným záporným znaménkemResult: Integer digits with optional negative sign.

Podporováno: Pouze integrální typy.Supported by: Integral types only.

Specifikátor přesnosti: Minimální počet číslicPrecision specifier: Minimum number of digits.

Výchozí specifikátor přesnosti: Vyžaduje se minimální počet číslic.Default precision specifier: Minimum number of digits required.

Další informace: Specifikátor formátu desítkového čísla ("D").More information: The Decimal("D") Format Specifier.
1234 ("D")-> 12341234 ("D") -> 1234

-1234 ("D6")->-001234-1234 ("D6") -> -001234
"E" nebo "e""E" or "e" Exponenciální (vědecký) zápisExponential (scientific) Vyústit Exponenciální notaceResult: Exponential notation.

Podporováno: Všechny číselné typy.Supported by: All numeric types.

Specifikátor přesnosti: Počet desetinných číslic.Precision specifier: Number of decimal digits.

Výchozí specifikátor přesnosti: 6.Default precision specifier: 6.

Další informace: Exponenciální specifikátor formátu ("E").More information: The Exponential ("E") Format Specifier.
1052,0329112756 ("E", en-US)-> 1.052033 E + 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,05 e + 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" nebo "f""F" or "f" Pevná desetinná čárkaFixed-point Vyústit Celočíselná a desítková čísla s volitelným záporným znaménkem.Result: Integral and decimal digits with optional negative sign.

Podporováno: Všechny číselné typy.Supported by: All numeric types.

Specifikátor přesnosti: Počet desetinných číslic.Precision specifier: Number of decimal digits.

Výchozí specifikátor přesnosti: NumberFormatInfo.NumberDecimalDigitsDefinováno.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Další informace: Specifikátor formátu s pevnou desetinnou čárkou ("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, 1234,5600-1234.56 ("F4", de-DE) -> -1234,5600
"G" nebo "g""G" or "g" ObecnéGeneral Vyústit Kompaktnější z pevného bodu nebo vědeckého zápisu.Result: The more compact of either fixed-point or scientific notation.

Podporováno: Všechny číselné typy.Supported by: All numeric types.

Specifikátor přesnosti: Počet platných číslicPrecision specifier: Number of significant digits.

Výchozí specifikátor přesnosti: Závisí na číselném typu.Default precision specifier: Depends on numeric type.

Další informace: Obecný specifikátor formátu ("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.234567890 e-25 ("G", en-US)->-1.23456789 E-25-1.234567890e-25 ("G", en-US) -> -1.23456789E-25

-1.234567890 e-25 ("G", sv-SE)->-1, 23456789E-25-1.234567890e-25 ("G", sv-SE) -> -1,23456789E-25
"N" nebo "n""N" or "n" ČísloNumber Vyústit Celočíselné a desítkové číslice, oddělovače skupin a oddělovač desetinných míst s volitelným záporným znaménkem.Result: Integral and decimal digits, group separators, and a decimal separator with optional negative sign.

Podporováno: Všechny číselné typy.Supported by: All numeric types.

Specifikátor přesnosti: Požadovaný počet desetinných míst.Precision specifier: Desired number of decimal places.

Výchozí specifikátor přesnosti: NumberFormatInfo.NumberDecimalDigitsDefinováno.Default precision specifier: Defined by NumberFormatInfo.NumberDecimalDigits.

Další informace: Číselný specifikátor formátu ("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" nebo "p""P" or "p" ProcentoPercent Vyústit Číslo vynásobené 100em a zobrazeným symbolem procentaResult: Number multiplied by 100 and displayed with a percent symbol.

Podporováno: Všechny číselné typy.Supported by: All numeric types.

Specifikátor přesnosti: Požadovaný počet desetinných míst.Precision specifier: Desired number of decimal places.

Výchozí specifikátor přesnosti: NumberFormatInfo.PercentDecimalDigitsDefinováno.Default precision specifier: Defined by NumberFormatInfo.PercentDecimalDigits.

Další informace: Procentuální specifikátor formátu ("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" nebo "r""R" or "r" Zpáteční převodRound-trip Vyústit Řetězec, který může být zpáteční cestou k stejnému číslu.Result: A string that can round-trip to an identical number.

Podporováno v: Single, Doublea BigInteger.Supported by: Single, Double, and BigInteger.

Poznámka: Doporučuje se BigInteger jenom pro typ.Note: Recommended for the BigInteger type only. Pro Double typy použijte "G17"; pro Single typy použijte "G9".For Double types, use "G17"; for Single types, use "G9".
Specifikátor přesnosti: Přeskočen.Precision specifier: Ignored.

Další informace: Specifikátor formátu Round-Trip ("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" nebo "x""X" or "x" Šestnáctková hodnotaHexadecimal Vyústit Šestnáctkový řetězec.Result: A hexadecimal string.

Podporováno: Pouze integrální typy.Supported by: Integral types only.

Specifikátor přesnosti: Počet číslic ve výsledném řetězci.Precision specifier: Number of digits in the result string.

Další informace: Šestnáctkový specifikátor formátu ("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
Jakýkoli jiný samostatný znakAny other single character Neznámý specifikátorUnknown specifier Vyústit Vyvolá za běhu v době běhu. FormatExceptionResult: Throws a FormatException at run time.

Používání řetězců standardního číselného formátuUsing Standard Numeric Format Strings

Poznámka

Ukázky C#, v tomto článku spusťte Try.NET runner a playground vloženého kódu.The C# examples in this article run in the Try.NET inline code runner and playground. Vyberte spustit tlačítko spustit příklad v interaktivním okně.Select the Run button to run an example in an interactive window. Jakmile se při spuštění kódu, můžete upravit a spustit upravený kód tak, že vyberete spustit znovu.Once you execute the code, you can modify it and run the modified code by selecting Run again. Upravené kód je buď spuštěn v interaktivním okně, nebo pokud kompilace se nezdaří, interaktivní okno zobrazuje všechny jazyka C# kompilátoru chybové zprávy.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Řetězec standardního číselného formátu lze použít pro definování formátování číselné hodnoty jedním ze dvou způsobů:A standard numeric format string can be used to define the formatting of a numeric value in one of two ways:

  • Může být předán přetížení ToString metody, která format má parametr.It can be passed to an overload of the ToString method that has a format parameter. Následující příklad formátuje číselnou hodnotu jako řetězec měny v aktuální jazykové verzi (v tomto případě jazykovou verzi 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
    
  • formatString Dá se zadat jako argument v položce formátu používané s těmito metodami jako String.Format, Console.WriteLinea 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. Další informace najdete v tématu složené formátování.For more information, see Composite Formatting. Následující příklad používá položku formátu pro vložení hodnoty měny do řetězce.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."
    

    Volitelně můžete alignment zadat argument pro určení šířky číselného pole a zda je jeho hodnota zarovnána vpravo nebo vlevo.Optionally, you can supply an alignment argument to specify the width of the numeric field and whether its value is right- or left-aligned. Následující příklad Zarovná hodnotu měny v poli se 28 znaky a v poli se 14 znaky Zarovná hodnotu měny.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      
    
  • Dá se zadat jako formatString argument v položce interpolované výrazu interpolované řetězcové položky.It can be supplied as the formatString argument in an interpolated expression item of an interpolated string. Další informace naleznete v tématu o interpolaci řetězce v C# odkazu nebo v tématu interpolované řetězce v odkazu Visual Basic.For more information, see the String interpolation topic in the C# reference or the Interpolated strings topic in the Visual Basic reference.

Následující oddíly obsahují podrobné informace o jednotlivých řetězcích standardního číselného formátu.The following sections provide detailed information about each of the standard numeric format strings.

Specifikátor formátu měny ("C")The Currency ("C") Format Specifier

Specifikátor formátu "C" (neboli měny) převede číslo na řetězec, který představuje peněžní částku.The "C" (or currency) format specifier converts a number to a string that represents a currency amount. Specifikátor přesnosti označuje požadovaný počet desetinných míst ve výsledném řetězci.The precision specifier indicates the desired number of decimal places in the result string. Pokud je specifikátor přesnosti vynechán, je výchozí přesnost definována NumberFormatInfo.CurrencyDecimalDigits vlastností.If the precision specifier is omitted, the default precision is defined by the NumberFormatInfo.CurrencyDecimalDigits property.

Pokud má formátovaná hodnota větší než zadaný nebo výchozí počet desetinných míst, je desetinná hodnota ve výsledném řetězci zaokrouhlena.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. Pokud je vpravo od zadaného počtu desetinných míst hodnota 5 nebo vyšší, bude poslední číslice ve výsledném řetězci zaokrouhlena směrem nahoru.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.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. V následující tabulce jsou uvedeny NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
CurrencyPositivePattern Definuje umístění symbolu měny pro kladné hodnoty.Defines the placement of the currency symbol for positive values.
CurrencyNegativePattern Definuje umístění symbolu měny pro záporné hodnoty a určuje, zda je záporné znaménko představováno závorkami nebo NegativeSign vlastností.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 Definuje záporné znaménko, které CurrencyNegativePattern se používá, pokud označuje, že se nepoužívají kulaté závorky.Defines the negative sign used if CurrencyNegativePattern indicates that parentheses are not used.
CurrencySymbol Definuje symbol měny.Defines the currency symbol.
CurrencyDecimalDigits Definuje výchozí počet desítkových číslic v hodnotě měny.Defines the default number of decimal digits in a currency value. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti.This value can be overridden by using the precision specifier.
CurrencyDecimalSeparator Definuje řetězec, který odděluje integrální a desítkové číslice.Defines the string that separates integral and decimal digits.
CurrencyGroupSeparator Definuje řetězec, který odděluje skupiny integrálních čísel.Defines the string that separates groups of integral numbers.
CurrencyGroupSizes Definuje počet celých číslic, které se zobrazují ve skupině.Defines the number of integer digits that appear in a group.

Následující příklad formátuje Double hodnotu pomocí specifikátoru formátu měny: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

Zpět na tabulkuBack to table

Specifikátor formátu desítkového čísla ("D")The Decimal ("D") Format Specifier

Specifikátor formátu "D" (desítkové číslo) převede číslo na řetězec desítkových číslic (0-9), kterému předchází symbol mínus, je-li číslo záporné.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. Tento formát je podporován pouze pro integrální typy.This format is supported only for integral types.

Specifikátor přesnosti označuje minimální počet číslic požadovaných ve výsledném řetězci.The precision specifier indicates the minimum number of digits desired in the resulting string. V případě potřeby je číslo doplněno nulami po levé straně za účelem vytvoření počtu číslic, který je dán specifikátorem přesnosti.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier. Pokud není zadán žádný specifikátor přesnosti, je výchozí hodnotou minimální hodnota požadovaná k vytvoření celého čísla bez počátečních nul.If no precision specifier is specified, the default is the minimum value required to represent the integer without leading zeros.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. Jak znázorňuje následující tabulka, jediná vlastnost ovlivňuje formátování výsledného řetězce.As the following table shows, a single property affects the formatting of the result string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.Defines the string that indicates that a number is negative.

Následující příklad formátuje Int32 hodnotu se specifikátorem desítkového formátu.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

Zpět na tabulkuBack to table

Exponenciální specifikátor formátu ("E")The Exponential ("E") Format Specifier

Exponenciální specifikátor formátu ("E") převede číslo na řetězec ve formě "-d.ddd…E+ddd" nebo "-d.ddd…e+ddd", kde každé "d" označuje číslici (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). Pokud je číslo záporné, řetězec začíná symbolem mínus.The string starts with a minus sign if the number is negative. Desetinné čárce předchází vždy přesně jedna číslice.Exactly one digit always precedes the decimal point.

Specifikátor přesnosti označuje požadovaný počet číslic za desetinnou čárkou.The precision specifier indicates the desired number of digits after the decimal point. Pokud specifikátor přesnosti vynecháte, je za desetinnou čárkou použit výchozí počet šesti číslic.If the precision specifier is omitted, a default of six digits after the decimal point is used.

Velikost specifikátoru formátu označuje, zda má být před exponentem použita předpona "E" nebo "e".The case of the format specifier indicates whether to prefix the exponent with an "E" or an "e". Exponent se skládá vždy ze znaménka plus nebo mínus a minimálně tří číslic.The exponent always consists of a plus or minus sign and a minimum of three digits. Aby byl tento minimální požadavek splněn, je exponent v případě potřeby doplněn nulami.The exponent is padded with zeros to meet this minimum, if required.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. V následující tabulce jsou uvedeny NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
NegativeSign Definuje řetězec, který označuje, že číslo je záporné pro koeficient i pro exponent.Defines the string that indicates that a number is negative for both the coefficient and exponent.
NumberDecimalSeparator Definuje řetězec, který odděluje integrální číslice od desítkových číslic v koeficientu.Defines the string that separates the integral digit from decimal digits in the coefficient.
PositiveSign Definuje řetězec, který označuje, že exponent je kladný.Defines the string that indicates that an exponent is positive.

Následující příklad formátuje Double hodnotu pomocí exponenciálního specifikátoru formátu: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

Zpět na tabulkuBack to table

Specifikátor formátu s pevnou desetinnou čárkou ("F")The Fixed-Point ("F") Format Specifier

Specifikátor formátu s pevnou desetinnou čárkou ("F") převede číslo na řetězec ve formátu "-ddd. ddd...". kde každé "d" označuje číslici (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). Pokud je číslo záporné, řetězec začíná symbolem mínus.The string starts with a minus sign if the number is negative.

Specifikátor přesnosti označuje požadovaný počet desetinných míst.The precision specifier indicates the desired number of decimal places. Pokud je specifikátor přesnosti vynechán, aktuální NumberFormatInfo.NumberDecimalDigits vlastnost poskytuje číselnou přesnost.If the precision specifier is omitted, the current NumberFormatInfo.NumberDecimalDigits property supplies the numeric precision.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. V následující tabulce jsou uvedeny vlastnosti NumberFormatInfo objektu, které řídí formátování výsledného řetězce.The following table lists the properties of the NumberFormatInfo object that control the formatting of the result string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definuje řetězec, který odděluje integrální číslice od desítkových číslic.Defines the string that separates integral digits from decimal digits.
NumberDecimalDigits Definuje výchozí počet desítkových číslic.Defines the default number of decimal digits. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti.This value can be overridden by using the precision specifier.

Následující příklad formátuje Double Int32 a a hodnotu pomocí specifikátoru formátu s pevnou desetinnou čárkou: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                        

Zpět na tabulkuBack to table

Specifikátor obecného formátu ("G")The General ("G") Format Specifier

Obecný specifikátor formátu ("G") převede číslo na více kompaktních hodnot s pevnou desetinnou čárkou nebo vědeckým zápisem v závislosti na typu čísla a na tom, zda je k dispozici specifikátor přesnosti.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. Specifikátor přesnosti definuje maximální počet platných číslic, které mohou být zobrazeny ve výsledném řetězci.The precision specifier defines the maximum number of significant digits that can appear in the result string. Pokud specifikátor přesnosti vynecháte nebo je specifikátor nulový, pak typ čísla určuje výchozí přesnost, jak je uvedeno v následující tabulce.If the precision specifier is omitted or zero, the type of the number determines the default precision, as indicated in the following table.

Číselný typNumeric type Výchozí přesnostDefault precision
Byte Nebo SByteByte or SByte 3 číslice3 digits
Int16 Nebo UInt16Int16 or UInt16 5 číslic5 digits
Int32 Nebo UInt32Int32 or UInt32 10 číslic10 digits
Int64 19 číslic19 digits
UInt64 20 číslic20 digits
BigInteger Neomezeno (stejné jako "R")Unlimited (same as "R")
Single 7 číslic7 digits
Double 15 číslic15 digits
Decimal 29 číslic29 digits

Zápis s pevnou desetinnou čárkou se používá v případě, že exponent, který by byl výsledkem vyjádření čísla ve vědeckém zápisu, je větší než -5 a menší než specifikátor přesnosti. Jinak se použije vědecký zápis.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. V případě potřeby obsahuje výsledek desetinnou čárku a koncové nuly po vynechání desetinné čárky.The result contains a decimal point if required, and trailing zeros after the decimal point are omitted. Pokud je k dispozici specifikátor přesnosti a počet platných číslic ve výsledku překračuje zadanou přesnost, pak jsou přebytečné koncové nuly odstraněny zaokrouhlením.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.

Pokud je Decimal však číslo a specifikátor přesnosti vynecháno, je vždy použit zápis s pevnou desetinnou čárkou a koncové nuly jsou zachovány.However, if the number is a Decimal and the precision specifier is omitted, fixed-point notation is always used and trailing zeros are preserved.

Pokud použijete vědecký zápis, pak je před exponentem ve výsledku předpona "E", je-li specifikátor formát "G"; nebo předpona "e", je-li specifikátor formátu "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". Exponent obsahuje minimálně dvě číslice.The exponent contains a minimum of two digits. Tím se liší od formátu pro vědecký zápis, který je vytvořen exponenciálním specifikátorem formátu, což zahrnuje minimálně tři číslice v exponentu.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.

Všimněte si, že při použití s Double hodnotou specifikátor formátu "G17" zajišťuje úspěšné odezvy původní Double hodnoty.Note that, when used with a Double value, the "G17" format specifier ensures that the original Double value successfully round-trips. Důvodem je Double to, že je číslo s plovoucí desetinnou čárkoubinary64() s dvojitou přesností kompatibilní s IEEE 754-2008, které poskytuje až 17 platných číslic přesnosti.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. Doporučujeme použít místo specifikátoru formátu "r", protože v některých případech "r" nemůže úspěšně přesměrovat hodnoty s plovoucí desetinnou čárkou s dvojitou přesností na cestu.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. Následující příklad ukazuje jeden takový případ.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
  

Při použití s Single hodnotou specifikátor formátu "G9" zajišťuje, aby původní Single hodnota úspěšně převedla odezvy.When used with a Single value, the "G9" format specifier ensures that the original Single value successfully round-trips. Důvodem je Single to, že se jedná o číslo s plovoucí desetinnoubinary32čárkou () s přesností na IEEE 754-2008, které poskytuje až devět platných číslic přesnosti.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. Z důvodů výkonu doporučujeme použít místo specifikátoru formátu "R".For performance reasons, we recommend its use instead of the "R" format specifier.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. V následující tabulce jsou uvedeny NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definuje řetězec, který odděluje integrální číslice od desítkových číslic.Defines the string that separates integral digits from decimal digits.
PositiveSign Definuje řetězec, který označuje, že exponent je kladný.Defines the string that indicates that an exponent is positive.

Následující příklad formátuje různé hodnoty s plovoucí desetinnou čárkou pomocí obecného specifikátoru formátu: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    

Zpět na tabulkuBack to table

Specifikátor číselného formátu ("N")The Numeric ("N") Format Specifier

Specifikátor číselného formátu ("N") převede číslo na řetězec ve formě "-d,ddd,ddd.ddd…", kde "-" označuje symbol záporného čísla, je-li vyžadován, "d" označuje číslice (0-9), "," označuje oddělovač skupin a "." označuje symbol desetinné čárky.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. Specifikátor přesnosti označuje požadovaný počet číslic za desetinnou čárkou.The precision specifier indicates the desired number of digits after the decimal point. Pokud je specifikátor přesnosti vynechán, je počet desetinných míst definován aktuální NumberFormatInfo.NumberDecimalDigits vlastností.If the precision specifier is omitted, the number of decimal places is defined by the current NumberFormatInfo.NumberDecimalDigits property.

Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. V následující tabulce jsou uvedeny NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.Defines the string that indicates that a number is negative.
NumberNegativePattern Definuje formát záporných hodnot a určuje, zda je záporné znaménko představováno závorkami nebo NegativeSign vlastností.Defines the format of negative values, and specifies whether the negative sign is represented by parentheses or the NegativeSign property.
NumberGroupSizes Definuje počet integrálních číslic zobrazených mezi oddělovači skupin.Defines the number of integral digits that appear between group separators.
NumberGroupSeparator Definuje řetězec, který odděluje skupiny integrálních čísel.Defines the string that separates groups of integral numbers.
NumberDecimalSeparator Definuje řetězec, který odděluje integrální a desítkové číslice.Defines the string that separates integral and decimal digits.
NumberDecimalDigits Definuje výchozí počet desítkových číslic.Defines the default number of decimal digits. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti.This value can be overridden by using a precision specifier.

Následující příklad formátuje různé hodnoty s plovoucí desetinnou čárkou pomocí specifikátoru číselného formátu: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 

Zpět na tabulkuBack to table

Specifikátor procentuálního formátu ("P")The Percent ("P") Format Specifier

Specifikátor procentuálního formátu ("P") vynásobí číslo 100 a převede ho na řetězec, který představuje procenta.The percent ("P") format specifier multiplies a number by 100 and converts it to a string that represents a percentage. Specifikátor přesnosti označuje požadovaný počet desetinných míst.The precision specifier indicates the desired number of decimal places. Pokud je specifikátor přesnosti vynechán, je použita výchozí číselná přesnost dodaná aktuální PercentDecimalDigits vlastností.If the precision specifier is omitted, the default numeric precision supplied by the current PercentDecimalDigits property is used.

V následující tabulce jsou uvedeny NumberFormatInfo vlastnosti, které řídí formátování vráceného řetězce.The following table lists the NumberFormatInfo properties that control the formatting of the returned string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
PercentPositivePattern Definuje umístění symbolu procenta pro kladné hodnoty.Defines the placement of the percent symbol for positive values.
PercentNegativePattern Definuje umístění symbolu procenta a záporného symbolu pro záporné hodnoty.Defines the placement of the percent symbol and the negative symbol for negative values.
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.Defines the string that indicates that a number is negative.
PercentSymbol Definuje symbol procenta.Defines the percent symbol.
PercentDecimalDigits Definuje výchozí počet desetinných míst v procentuální hodnotě.Defines the default number of decimal digits in a percentage value. Tuto hodnotu lze přepsat pomocí specifikátoru přesnosti.This value can be overridden by using the precision specifier.
PercentDecimalSeparator Definuje řetězec, který odděluje integrální a desítkové číslice.Defines the string that separates integral and decimal digits.
PercentGroupSeparator Definuje řetězec, který odděluje skupiny integrálních čísel.Defines the string that separates groups of integral numbers.
PercentGroupSizes Definuje počet celých číslic, které se zobrazují ve skupině.Defines the number of integer digits that appear in a group.

Následující příklad formátuje hodnoty s plovoucí desetinnou čárkou pomocí specifikátoru formátu procenta: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 %

Zpět na tabulkuBack to table

Specifikátor formátu zpátečního převodu ("R")The Round-trip ("R") Format Specifier

Specifikátor formátu Round-Trip ("R") se pokusí zajistit, že číselná hodnota, která je převedena na řetězec, bude analyzována zpět do stejné číselné hodnoty.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. Tento formát je podporován pouze pro Singletypy, Doublea. BigIntegerThis format is supported only for the Single, Double, and BigInteger types.

Pro Double hodnoty specifikátor formátu "R" v některých případech se nepodaří úspěšně odeslat původní hodnotu z cesty.For Double values, the "R" format specifier in some cases fails to successfully round-trip the original value. U obou Double Single hodnot i nabízí také poměrně špatný výkon.For both Double and Single values, it also offers relatively poor performance. Místo toho doporučujeme použít specifikátor formátu "G17" pro Double hodnoty a Single specifikátor formátu "G9" k úspěšnému zacyklení hodnot.Instead, we recommend that you use the "G17" format specifier for Double values and the "G9" format specifier to successfully round-trip Single values.

Pokud je BigInteger hodnota formátována pomocí tohoto specifikátoru, Řetězcová reprezentace obsahuje všechny významné číslice v hodnotě. BigIntegerWhen a BigInteger value is formatted using this specifier, its string representation contains all the significant digits in the BigInteger value.

Ačkoli můžete použít také specifikátor přesnosti, bude ignorován.Although you can include a precision specifier, it is ignored. Pokud použijete tento specifikátor, má zpáteční převod přednost nad přesností.Round trips are given precedence over precision when using this specifier. Na výsledný řetězec má vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is affected by the formatting information of the current NumberFormatInfo object. V následující tabulce jsou uvedeny NumberFormatInfo vlastnosti, které řídí formátování výsledného řetězce.The following table lists the NumberFormatInfo properties that control the formatting of the result string.

Vlastnost NumberFormatInfoNumberFormatInfo property PopisDescription
NegativeSign Definuje řetězec, který označuje, že číslo je záporné.Defines the string that indicates that a number is negative.
NumberDecimalSeparator Definuje řetězec, který odděluje integrální číslice od desítkových číslic.Defines the string that separates integral digits from decimal digits.
PositiveSign Definuje řetězec, který označuje, že exponent je kladný.Defines the string that indicates that an exponent is positive.

Následující příklad formátuje BigInteger hodnotu pomocí specifikátoru formátu Round-Trip.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  

Důležité

V některých případech Double hodnoty formátované pomocí standardního číselného formátovacího řetězce "R" nemusejí úspěšně odcyklovat cestu, pokud jsou /platform:x64 kompilovány pomocí přepínačů nebo /platform:anycpu a spouštěny v 64 systémech.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. Další informace najdete v následujícím článku.See the following paragraph for more information.

Chcete-li se vyhnout problému Double hodnot formátovaných pomocí standardního číselného formátovacího řetězce "R", neúspěšně se zaokrouhlí na /platform:x64 Trip /platform:anycpu , pokud jsou kompilovány pomocí přepínačů nebo a spouštěny v Double systémech 64. můžete formátovat hodnoty pomocí standardního číselného formátovacího řetězce "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. Následující příklad používá formátovací řetězec "R" s Double hodnotou, která neprovádí operaci round-trip, a také používá řetězec formátu "G17" k úspěšnému přenosu původní hodnoty: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

Zpět na tabulkuBack to table

Specifikátor šestnáctkového formátu ("X")The Hexadecimal ("X") Format Specifier

Specifikátor šestnáctkového formátu ("X") převede číslo na řetězec šestnáctkových číslic.The hexadecimal ("X") format specifier converts a number to a string of hexadecimal digits. Velikost specifikátoru formátu označuje, zda pro šestnáctkové číslice, které jsou větší než 9, je nutné používat velká nebo malá písmena.The case of the format specifier indicates whether to use uppercase or lowercase characters for hexadecimal digits that are greater than 9. Například pro vytvoření řetězce "ABCDEF" použijte formát "X", pro vytvoření řetězce "abcdef" použijte formát "x".For example, use "X" to produce "ABCDEF", and "x" to produce "abcdef". Tento formát je podporován pouze pro integrální typy.This format is supported only for integral types.

Specifikátor přesnosti označuje minimální počet číslic požadovaných ve výsledném řetězci.The precision specifier indicates the minimum number of digits desired in the resulting string. V případě potřeby je číslo doplněno nulami po levé straně za účelem vytvoření počtu číslic, který je dán specifikátorem přesnosti.If required, the number is padded with zeros to its left to produce the number of digits given by the precision specifier.

Na výsledný řetězec nemá vliv informace o formátování aktuálního NumberFormatInfo objektu.The result string is not affected by the formatting information of the current NumberFormatInfo object.

Následující příklad formátuje Int32 hodnoty pomocí hexadecimálního specifikátoru formátu.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

Zpět na tabulkuBack to table

PoznámkyNotes

Nastavení části Ovládací panelyControl Panel Settings

Nastavení v položce místní a jazykové nastavení v Ovládacích panelech ovlivní výsledný řetězec vytvořený při operaci formátování.The settings in the Regional and Language Options item in Control Panel influence the result string produced by a formatting operation. Tato nastavení slouží k inicializaci NumberFormatInfo objektu přidruženého k aktuální jazykové verzi vlákna, které poskytuje hodnoty použité k řízení formátování.Those settings are used to initialize the NumberFormatInfo object associated with the current thread culture, which provides values used to govern formatting. Počítače, které používají různá nastavení, generují různé výsledné řetězce.Computers that use different settings generate different result strings.

Kromě toho, pokud CultureInfo.CultureInfo(String) je konstruktor použit k vytvoření instance nového CultureInfo objektu, který představuje stejnou jazykovou verzi jako aktuální jazyková verze systému, jakákoli vlastní nastavení, která byla vytvořena položkou místní a jazykové nastavení v Ovládacích panelech bude použito pro nový CultureInfo objekt.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. CultureInfo.CultureInfo(String, Boolean) Konstruktor můžete použít k CultureInfo vytvoření objektu, který nereflektuje vlastní nastavení systému.You can use the CultureInfo.CultureInfo(String, Boolean) constructor to create a CultureInfo object that does not reflect a system's customizations.

Vlastnosti objektu NumberFormatInfoNumberFormatInfo Properties

Formátování je ovlivněno vlastnostmi aktuálního NumberFormatInfo objektu, který je poskytnut implicitně aktuální jazykovou verzí vlákna nebo explicitně IFormatProvider parametrem metody, která vyvolá formátování.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. Zadejte objekt CultureInfo nebo pro tento parametr. NumberFormatInfoSpecify a NumberFormatInfo or CultureInfo object for that parameter.

Poznámka

Informace o přizpůsobení vzorů nebo řetězců použitých ve formátování číselných hodnot naleznete NumberFormatInfo v tématu třídy.For information about customizing the patterns or strings used in formatting numeric values, see the NumberFormatInfo class topic.

Integrální typy čísel a typy s plovoucí desetinnou čárkouIntegral and Floating-Point Numeric Types

Některé popisy specifikátorů standardního číselného formátu odkazují na integrální číselné typy nebo typy s plovoucí desetinnou čárkou.Some descriptions of standard numeric format specifiers refer to integral or floating-point numeric types. Integrální Bytečíselné typy jsou, Int64 ,UInt16,,, ,UInt64, aBigInteger. Int16 SByte Int32 UInt32The integral numeric types are Byte, SByte, Int16, Int32, Int64, UInt16, UInt32, UInt64, and BigInteger. Číselné typy s plovoucí desetinnou čárkou Singlejsou Decimal, Doublea.The floating-point numeric types are Decimal, Single, and Double.

Nekonečno s plovoucí desetinnou čárkou a NaNFloating-Point Infinities and NaN

Bez ohledu na řetězec formátu, Single Pokud je hodnota nebo Double typu s plovoucí desetinnou čárkou kladné nekonečno, záporné nekonečno nebo není číslo (NaN), formátovaný řetězec je hodnota příslušné PositiveInfinitySymbolhodnoty, NegativeInfinitySymbolnebo NaNSymbol vlastnost, která je určena aktuálně použitelným NumberFormatInfo objektem.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.

PříkladExample

Poznámka

Některé příklady jazyka C# v tomto článku spustit Try.NET runner a playground vloženého kódu.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Vyberte spustit tlačítko spustit příklad v interaktivním okně.Select the Run button to run an example in an interactive window. Jakmile se při spuštění kódu, můžete upravit a spustit upravený kód tak, že vyberete spustit znovu.Once you execute the code, you can modify it and run the modified code by selecting Run again. Upravené kód je buď spuštěn v interaktivním okně, nebo pokud kompilace se nezdaří, interaktivní okno zobrazuje všechny jazyka C# kompilátoru chybové zprávy.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Následující příklad formátuje číselnou integrální hodnotu a hodnotu s plovoucí desetinnou čárkou pomocí jazykové verze en-US a všech specifikátorů standardního číselného formátu.The following example formats an integral and a floating-point numeric value using the en-US culture and all the standard numeric format specifiers. V tomto příkladu se používají dva konkrétní číselnéDouble typy Int32(a), ale by výsledkem byly podobné výsledky pro libovolný z dalších číselnýchBytezákladních SByte Int32typů Int16(, Int64,,,, UInt16, ,UInt64, ,Singlea )Decimal. UInt32 BigIntegerThis 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

Viz také:See also