Stringhe di formato numerico personalizzato

È possibile creare una stringa di formato numerico personalizzata costituita da uno o più identificatori numerici personalizzati, per definire la formattazione dei dati numerici. Una stringa di formato numerico personalizzata è qualsiasi stringa di formato che non è una stringa di formato numerico standard.

Nella tabella seguente vengono descritti gli identificatori di formato numerico personalizzati e viene visualizzato l'output di esempio prodotto da ogni identificatore di formato. Per altre informazioni sull'uso di stringhe di formato numerico personalizzate, vedere la sezione Esempio per un'illustrazione completa dell'uso.

Nelle sezioni seguenti vengono fornite informazioni dettagliate su ognuno degli identificatori di formato numerico personalizzati.

Identificatore personalizzato "0"

L'identificatore di formato personalizzato "0" serve come simbolo di segnaposto zero. Se nel valore da formattare è presente una cifra nella posizione in cui nella stringa di formato si trova lo zero, tale cifra viene copiata nella stringa di risultato. In caso contrario, nella stringa di risultato viene visualizzato uno zero. La posizione dello zero più a sinistra prima del separatore decimale e quella dello zero più a destra dopo il separatore decimale determinano l'intervallo di cifre sempre presenti nella stringa di risultato.

L'identificatore "00" determina l'arrotondamento del valore alla cifra più vicina prima del decimale, in cui viene sempre usato l'arrotondamento a un valore diverso da zero. La formattazione di 34,5 con "00", ad esempio, restituisce come risultato il valore 35.

Nell'esempio seguente vengono visualizzati diversi valori formattati usando stringhe di formato personalizzate che includono segnaposto zero.

let
    Source =
    {
        Number.ToText(123, "00000", ""),
        // Displays 00123

        Number.ToText(1.2, "0.00", ""),
        // Displays 1.20

        Number.ToText(1.2, "00.00", ""),
        // Displays 01.20

        Number.ToText(1.2, "00.00", "da-DK"),
        // Displays 01,20

        Number.ToText(.56, "0.0", ""),
        // Displays 0.6

        Number.ToText(1234567890, "0,0", ""),
        // Displays 1,234,567,890

        Number.ToText(1234567890, "0,0", "el-GR"),
        // Displays 1.234.567.890

        Number.ToText(1234567890.123456, "0,0.0", ""),
        // Displays 1,234,567,890.1

        Number.ToText(1234.567890, "0,0.00", "")
        // Displays 1,234.57
    }
in
    Source

Torna alla tabella

Identificatore personalizzato "#"

L'identificatore di formato personalizzato "#" serve come simbolo di segnaposto per cifre. Se il valore da formattare ha una cifra nella posizione in cui si trova il simbolo "#" nella stringa di formato, tale cifra viene copiata nella stringa di risultato. In caso contrario, nella stringa di risultato non viene memorizzato alcun valore in tale posizione.

Si noti che questo identificatore non visualizza mai uno zero che non è una cifra significativa, anche se zero è l'unica cifra nella stringa. Viene visualizzato zero solo se si tratta di una cifra significativa nel numero visualizzato.

La stringa di formato "##" determina l'arrotondamento del valore alla cifra più vicina prima del decimale, in cui viene sempre usato l'arrotondamento a un valore diverso da zero. La formattazione di 34,5 con "##", ad esempio, restituisce come risultato il valore 35.

Nell'esempio seguente vengono visualizzati diversi valori formattati usando stringhe di formato personalizzate che includono segnaposto per cifre.

let
    Source =
    {
        Number.ToText(1.2, "#.##", ""),
        // Displays 1.2

        Number.ToText(123, "#####"),
        // Displays 123

        Number.ToText(123456, "[##-##-##]"),
        // Displays [12-34-56]

        Number.ToText(1234567890, "#"),
        // Displays 1234567890

        Number.ToText(1234567890, "(###) ###-####")
        // Displays (123) 456-7890
    }
in
    Source

Per restituire una stringa di risultato in cui le cifre assenti o gli zeri iniziali vengono sostituiti da spazi, utilizzare il Text.PadStart e specificare una larghezza del campo, come illustrato nell'esempio seguente.

let
   Source = Text.Format("The value is: '#{0}'", {Text.PadStart(Number.ToText(.324, "#.###"), 5)})
in
   Source

// The example displays the following output if the current culture
// is en-US:
//      The value is: ' .324'

Torna alla tabella

Identificatore personalizzato "."

L'identificatore di formato personalizzato "." inserisce un separatore decimale localizzato nella stringa di risultato. Il primo carattere punto nella stringa di formato determina la posizione del separatore decimale nel valore formattato. Eventuali punti aggiuntivi vengono ignorati. Se l'identificatore di formato termina con un valore "." solo le cifre significative vengono formattate nella stringa di risultato.

Il carattere usato come separatore decimale nella stringa di risultato non è sempre un punto; è determinata dalle impostazioni cultura che controllano la formattazione.

Nell'esempio seguente viene usato l'identificatore di formato "." per definire la posizione del separatore decimale in alcune stringhe di risultato.

let
    Source =
    {
        Number.ToText(1.2, "0.00", ""),
        // Displays 1.20

        Number.ToText(1.2, "00.00", ""),
        // Displays 01.20

        Number.ToText(1.2, "00.00", "da-DK"),
        // Displays 01,20

        Number.ToText(.086, "#0.##%", ""),
        // Displays 8.6%

        Number.ToText(Double.From(86000), "0.###E+0", "")
        // Displays 8.6E+4
    }
in
    Source

Torna alla tabella

Identificatore personalizzato ","

Il carattere "," viene usato sia come separatore di gruppi che come identificatore di rappresentazione in scala dei numeri.

• Separatore di gruppi: se vengono specificate una o più virgole tra due segnaposto per cifre (0 o #) che formattano le cifre integrali di un numero, viene inserito un carattere di separazione di gruppi tra ogni gruppo di numeri nella parte integrale dell'output.

  Le impostazioni cultura determinano il carattere utilizzato come separatore del gruppo di numeri e le dimensioni di ogni gruppo di numeri. Se ad esempio vengono usate la stringa "#, #" e le impostazioni cultura invarianti per formattare il numero 1000, l'output sarà "1,000".

• Identificatore di rappresentazione in scala dei numeri: se vengono specificate una o più virgole immediatamente a sinistra del separatore decimale esplicito o implicito, il numero da formattare viene diviso per 1000 per ogni virgola presente. Se ad esempio viene usata la stringa "0" per formattare il numero 100 milioni, l'output sarà "100".

È possibile usare gli identificatori del separatore di gruppi e di rappresentazione in scala dei numeri nella stessa stringa di formato. Se ad esempio vengono usate la stringa "#,0,," e le impostazioni cultura invarianti per formattare il numero un miliardo, l'output sarà "1,000".

Nell'esempio seguente viene illustrato l'utilizzo della virgola come separatore di gruppi.

let
    Source =
    {
        Number.ToText(1234567890, "#,#", ""),
        // Displays 1,234,567,890

        Number.ToText(1234567890, "#,##0,,", "")
        // Displays, 1,235
    }
in
    Source

Nell'esempio seguente viene illustrato l'utilizzo della virgola come identificatore di rappresentazione in scala.

let
    Source =
    {
        Number.ToText(1234567890, "#,,", ""),
        // Displays 1235

        Number.ToText(1234567890, "#,,,", ""),
        // Displays 1

        Number.ToText(1234567890, "#,##0,,", "")
        // Displays 1,235
    }
in
    Source

Torna alla tabella

Identificatore personalizzato "%"

Un segno di percentuale (%) in una stringa di formato fa sì che un numero venga moltiplicato per 100 prima che venga formattato. Il simbolo di percentuale localizzato viene inserito nel numero stesso nella posizione in cui è stato inserito il segno % nella stringa di formato. Il carattere percentuale utilizzato è definito dalle impostazioni cultura.

Nell'esempio seguente viene definita una stringa di formato personalizzata che include l'identificatore personalizzato "%".

let
    Source = Number.ToText(.086, "#0.##%", "")
    // Displays 8.6%
in
    Source

Torna alla tabella

Identificatore personalizzato "‰"

Un carattere per mille (™ o \u2030) in una stringa di formato fa sì che un numero venga moltiplicato per 1000 prima che venga formattato. Il simbolo per mille appropriato viene inserito nella stringa restituita nella posizione in cui è stato inserito il simbolo ‰ nella stringa di formato. Il carattere per mille utilizzato è definito dalle impostazioni cultura, che fornisce informazioni di formattazione specifiche delle impostazioni cultura.

Nell'esempio seguente viene definita una stringa di formato personalizzata che include l'identificatore personalizzato "‰".

let
    Source = Number.ToText(.00354, "#0.##" & Character.FromNumber(0x2030), "")
    // Displays 3.54‰
in
    Source

Torna alla tabella

Identificatori personalizzati "E" ed "e"

Se nella stringa di formato è presente una delle stringhe "E", "E+", "E-", "e", "e+" o "e-" immediatamente seguita da almeno uno zero, il numero viene formattato usando la notazione scientifica con una "E" o "e" inserita tra il numero e l'esponente. Il numero di zeri che seguono l'indicatore della notazione scientifica determina il numero minimo di cifre da visualizzare nell'output per l'esponente. I formati "E+" ed "e+" indicano che l'esponente deve essere sempre preceduto da un segno più o meno. I formati "E", "E-", "e" ed "e-" indicano che solo gli esponenti negativi devono essere preceduti da un carattere di segno.

Nell'esempio seguente vengono formattati alcuni valori numerici usando gli identificatori per notazione scientifica.

let
    Source =
    {
        Number.ToText(86000, "0.###E+0", ""),
        // Displays 8.6E+4

        Number.ToText(86000, "0.###E+000", ""),
        // Displays 8.6E+004

        Number.ToText(86000, "0.###E-000", "")
        // Displays 8.6E004
    }
in
    Source

Torna alla tabella

Caratteri di escape

I simboli "#", "0", ".", ",", "%" e "‰" in una stringa di formato vengono interpretati come identificatori di formato anziché come caratteri letterali. A seconda della posizione in una stringa di formato personalizzata, i simboli maiuscoli e minuscoli "E" e + e - possono anche essere interpretati come identificatori di formato.

Per impedire che un carattere venga interpretato come identificatore di formato, è possibile:

• Anteporre la barra rovesciata.
• Racchiuderlo con una virgoletta singola.
• Racchiuderlo tra due virgolette doppie.

Ognuno di questi caratteri funge da caratteri di escape. Il carattere di escape indica che il carattere seguente è un valore letterale carattere che deve essere incluso nella stringa di risultato senza modifiche.

Per includere una barra rovesciata in una stringa dei risultati, è necessario aggiungere un carattere di escape facendolo quindi precedere da un'altra barra rovesciata (\\).

Per includere una virgoletta singola in una stringa di risultato, è necessario eseguirne l'escape con una barra rovesciata (\'). Se un'altra virgoletta singola non preceduta da caratteri di escape precede la virgoletta singola di escape, viene visualizzata invece la barra rovesciata ('\' visualizza \).

Per includere una virgoletta doppia in una stringa di risultato, è necessario eseguirne l'escape con una barra rovesciata (\"").

Nell'esempio seguente vengono utilizzati caratteri di escape per impedire all'operazione di formattazione di interpretare i caratteri "#", "0" e "" come caratteri di escape o identificatori di formato.

let
    Source =
    {
        Number.ToText(123, "\#\#\# ##0 dollars and \0\0 cents \#\#\#"),
        // Displays ### 123 dollars and 00 cents ###

        Number.ToText(123, "'###' ##0 dollars and '00' cents '###'"),
        // Displays ### 123 dollars and 00 cents ###

        Number.ToText(123, """###"" ##0 dollars and ""00"" cents ""###"""),
        // Displays ### 123 dollars and 00 cents ###

        Number.ToText(123, "\\\\\\ ##0 dollars and \0\0 cents \\\\\\"),
        // Displays \\\ 123 dollars and 00 cents \\\

        Number.ToText(123, "'\\\' ##0 dollars and '00' cents '\\\'"),
        // Displays \\\ 123 dollars and 00 cents \\\

        Number.ToText(123, """\\\"" ##0 dollars and ""00"" cents ""\\\""")
        // Displays \\\ 123 dollars and 00 cents \\\
    }
in
    Source

Torna alla tabella

Separatore di sezione ";"

Il punto e virgola (;) è un identificatore di formato condizionale che applica una formattazione diversa a un numero, a seconda del fatto che il suo valore sia positivo, negativo o zero. A tale scopo, una stringa di formato personalizzata può contenere un massimo di tre sezioni separate da punti e virgola. Queste sezioni sono descritte nella tabella seguente.

Con i separatori di sezione, quando viene formattato il valore finale viene ignorata qualsiasi formattazione preesistente associata a un numero. Quando vengono usati separatori di sezione, ad esempio, i numeri negativi vengono sempre visualizzati senza segno meno. Se si desidera che il valore formattato finale disponga di un segno meno, è opportuno includere il segno meno in modo esplicito nell'ambito dell'identificatore di formato personalizzato.

Nell'esempio seguente viene usato l'identificatore di formato ";" per formattare numeri positivi, negativi e zero in modo diverso.

let
    Source =
    {
        Number.ToText(1234, "##;(##)"),
        // Displays 1234

        Number.ToText(-1234, "##;(##)"),
        // Displays (1234)

        Number.ToText(0, "##;(##);**Zero**")
        // Displays **Zero**
    }
in
    Source

Torna alla tabella

Valori letterali carattere

Gli identificatori di formato presenti in una stringa di formato numerico personalizzato vengono sempre interpretati come caratteri di formattazione e mai come caratteri letterali. Sono inclusi i caratteri seguenti:

• 0
• #
• %
• ‰
• '
• \
• ""
• .
• ,
• E o e, in base alla posizione nella stringa di formato.

Tutti gli altri caratteri vengono sempre interpretati come valori letterali carattere e in un'operazione di formattazione vengono inclusi senza modifiche nella stringa di risultato. In un'operazione di analisi questi caratteri devono corrispondere esattamente ai caratteri nella stringa di input. Il confronto tiene conto di maiuscole e minuscole.

L'esempio seguente illustra un uso comune di unità di carattere letterale (in questo caso migliaia):

let
    Source = Number.ToText(123.8, "#,##0.0K")
    // Displays 123.8K
in
    Source

Esistono due modi per indicare che determinati caratteri devono essere interpretati come caratteri letterali e non come caratteri di formattazione, in modo da includerli in una stringa di risultato o eseguirne l'analisi in una stringa di input:

• Usando un carattere di escape per un carattere di formattazione. Per altre informazioni, vedere Caratteri di escape.

• Racchiudendo l'intera stringa letterale tra apostrofi.

L'esempio seguente usa entrambi gli approcci per includere i caratteri riservati in una stringa di formato numerico personalizzato.

let
    Source =
    {
        Number.ToText(9.3, "##.0\%"),
        // Displays 9.3%

        Number.ToText(9.3, "\'##\'"),
        // Displays '9'

        Number.ToText(9.3, "\\##\\"),
        // Displays \9\

        Number.ToText(9.3, "##.0'%'"),
        // Displays 9.3%

        Number.ToText(9.3, "'\'##'\'"),
        // Displays \9\

        Number.ToText(9.3, "##.0""%"""),
        // Displays 9.3%

        Number.ToText(9.3, "\""##\""")
        // Displays "9"
    }
in
    Source

Note

Valori infiniti a virgola mobile e NaN

Indipendentemente dalla stringa di formato, se il valore di un Decimal.Type, Single.Type o Double.Type tipo a virgola mobile è infinito positivo, infinito negativo o non un numero (NaN), la stringa formattata è il valore delle rispettive costanti Number.PositiveInfinity, Number.NegativeInfinityo Number.NaN specificate dalle impostazioni cultura attualmente applicabili.

Arrotondamento e stringhe di formato a virgola fissa

Per le stringhe di formato a virgola fissa ( ovvero le stringhe di formato di formato non scientifico), i numeri vengono arrotondati a quante posizioni decimali sono presenti segnaposto a destra del separatore decimale. Se la stringa di formato non contiene un separatore decimale, il numero viene arrotondato all'intero più vicino. Se le cifre del numero sono più numerose dei segnaposto per le cifre riportati a sinistra del separatore decimale, le cifre eccedenti vengono copiate nella stringa di risultato immediatamente prima del primo segnaposto per le cifre.

Torna alla tabella

Esempio

Nell'esempio seguente vengono illustrate due stringhe di formato numerico personalizzate. In entrambi i casi il segnaposto per le cifre (#) consente di visualizzare i dati numerici e tutti gli altri caratteri vengono copiati nella stringa di risultato.

let
    Source =
    {
        Number.ToText(1234567890, "(###) ###-####"),
        // Displays (123) 456-7890

        Number.ToText(42, "My Number = #")
        // Displays My number = 42
    }
in
    Source

Torna alla tabella

Contenuto correlato

• Impatto delle impostazioni cultura sulla formattazione del testo
• Conversione del tipo di numero
• Tipi di dati in Power Query
• Stringhe di formato numerico standard