Stringhe di formato di data e ora standard

Una stringa di formato di data e ora standard usa un singolo carattere come identificatore di formato per definire la rappresentazione testuale di un valore di ora e data. Qualsiasi stringa di formato di data e ora che contiene più di un carattere, incluso lo spazio vuoto, viene interpretata come una stringa di formato di data e ora personalizzata. È possibile usare una stringa di formato standard o personalizzata per definire la rappresentazione di testo risultante da un'operazione di formattazione.

Tabella degli identificatori di formato

Nella tabella seguente vengono descritti gli identificatori di formato di data e ora standard.

Funzionamento delle stringhe di formato standard

In un'operazione di formattazione, una stringa di formato standard è semplicemente un alias per una stringa di formato personalizzata. Il vantaggio dell'uso di un alias per fare riferimento a una stringa di formato personalizzata consiste nel fatto che, sebbene l'alias sia invariante, la stringa di formato personalizzata può variare. Questo aspetto è importante perché le rappresentazioni di stringa di valori di data e ora variano in genere in base alle impostazioni cultura. La stringa di formato standard "d" indica, ad esempio, che un valore di data e ora deve essere visualizzato usando uno schema di data breve. Per le impostazioni cultura invarianti questo schema è "MM/dd/yyyy". Per le impostazioni cultura fr-FR questo schema è "dd/MM/yyyy". Per le impostazioni cultura ja-JP questo schema è "yyyy/MM/dd".

Se in un'operazione di formattazione viene eseguito il mapping di una stringa di formato standard alla stringa di formato personalizzata di impostazioni cultura particolari, nell'applicazione possono essere definite le impostazioni cultura specifiche le cui stringhe di formato personalizzate vengono usate in una di queste modalità:

• È possibile usare le impostazioni cultura predefinite, o correnti. Nell'esempio seguente viene visualizzata una data usando il formato di data breve delle impostazioni cultura correnti. In questo caso le impostazioni cultura correnti sono en-US.

  let
      Source =
      {
          Date.ToText(#date(2024, 3, 15), [Format = "d"])
          //Displays 3/15/2024
      }
  in
      Source
  

• È possibile passare impostazioni cultura usate per formattare la data in base alle regole delle impostazioni cultura specifiche. Nell'esempio seguente viene visualizzata una data usando il formato di data breve delle impostazioni cultura pt-BR.

  let
      Source =
      {
          Date.ToText(#date(2024, 3, 15), [Format = "d", Culture = "pt-BR"])
          //Displays 15/03/2024
     }
  in
      Source
  

In alcuni casi la stringa di formato standard serve come una pratica abbreviazione per una stringa di formato personalizzata più lunga, che è invariante. In questa categoria rientrano quattro stringhe di formato standard: "O" (o "o"), "R" (o "r"), "s" e "u". Queste stringhe corrispondono a stringhe di formato personalizzate definite dalle impostazioni cultura invarianti. Producono rappresentazioni di stringa di valori di data e ora che dovranno essere identiche nelle diverse impostazioni cultura. Nella tabella seguente vengono fornite informazioni su queste quattro stringhe di formato di data e ora standard.

Le stringhe di formato standard possono essere usate anche nelle operazioni di analisi, che richiedono che una stringa di input sia esattamente conforme a un modello specifico per l'esito positivo dell'operazione di analisi. Molte stringhe di formato standard eseguono il mapping a più stringhe di formato personalizzate, pertanto un valore di data e ora può essere rappresentato in un'ampia gamma di formati e l'operazione di analisi ha comunque esito positivo.

Le sezioni seguenti descrivono gli identificatori di formato standard per i valori Date, DateTime, DateTimeZone e Time .

Formati di data

Questo gruppo include i formati seguenti:

• Identificatore di formato data breve ("d")
• Identificatore di formato data lunga ("D")

Identificatore di formato di data breve ("d")

L'identificatore di formato standard "d" rappresenta un formato di data personalizzato definito da impostazioni cultura specifiche. Ad esempio, il testo in formato personalizzato restituito dalle impostazioni cultura invarianti è "MM/gg/aaaa".

Nell'esempio seguente viene usato l'identificatore di formato "d" per visualizzare un valore di data.

let
    Source =
    {
        Date.ToText(#date(2024, 4, 10), [Format = "d", Culture = ""]),
        // Displays 04/10/2024

        Date.ToText(#date(2024, 4, 10), [Format = "d", Culture = "en-US"]),
        // Displays 4/10/2024

        Date.ToText(#date(2024, 4, 10), [Format = "d", Culture = "en-NZ"]),
        // Displays 10/4/2024

        Date.ToText(#date(2024, 4, 10), [Format = "d", Culture = "de-DE"])
        // Displays 10.4.2024
    }
in
    Source

Torna alla tabella

Identificatore di formato di data estesa ("D")

L'identificatore di formato standard "D" rappresenta un formato di data personalizzato definito da impostazioni cultura specifiche. La stringa di formato personalizzata per le impostazioni cultura invarianti ad esempio è "dddd, dd MMMM yyyy".

Nell'esempio seguente viene usato l'identificatore di formato "D" per visualizzare un valore di data e ora.

let
    Source =
    {
        Date.ToText(#date(2024, 4, 10), [Format = "D", Culture = ""]),
        // Displays Wednesday, 10 April, 2024

        Date.ToText(#date(2024, 4, 10), [Format = "D", Culture = "en-US"]),
        // Displays Wednesday, April 10, 2024

        Date.ToText(#date(2024, 4, 10), [Format = "D", Culture = "pt-BR"]),
        // Displays quarta-feira, 10 de abril de 2024

        Date.ToText(#date(2024, 4, 10), [Format = "D", Culture = "es-MX"])
        // Displays miércoles, 10 de abril de 2024
    }
in
    Source

Torna alla tabella

Formati di data e ora

Questo gruppo include i formati seguenti:

• Identificatore di formato full date short time ("f")
• Identificatore di formato full date long time ("F")
• Identificatore di formato di data breve ("g") generale
• Identificatore di formato di data estesa generale ("G")
• Identificatore di formato round trip ("O", "o")
• Identificatore di formato RFC1123 ("R", "r")
• Identificatore di formato ordinabile ("s")
• Identificatore di formato ordinabile universale ("u")

Identificatore di formato di ora breve e data completa ("f")

L'identificatore di formato standard "f" rappresenta una combinazione degli schemi di data estesa ("D") e ora breve ("t"), separati da uno spazio.

La stringa di risultato è influenzata dalle informazioni di formattazione di impostazioni cultura specifiche.

Nell'esempio seguente viene usato l'identificatore di formato "f" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "f", Culture = "en-US"]),
        // Displays Wednesday, April 10, 2024 6:30 AM

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "f", Culture = "fr-FR"])
        // Displays mercredi 10 avril 2024 06:30
    }
in
    Source

Torna alla tabella

Identificatore di formato di ora estesa e data completa ("F")

L'identificatore di formato standard "F" rappresenta un formato di data e ora personalizzato definito da impostazioni cultura specifiche. La stringa di formato personalizzata per le impostazioni cultura invarianti ad esempio è "dddd, dd MMMM yyyy HH:mm:ss".

La stringa di risultato è influenzata dalle informazioni di formattazione di impostazioni cultura specifiche.

Nell'esempio seguente viene usato l'identificatore di formato "F" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "F", Culture = ""]),
        // Displays Wednesday, 10 April, 2024 06:30:00

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "F", Culture = "en-US"]),
        // Displays Wednesday, April 10, 2024 6:30:00 AM

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "F", Culture = "fr-FR"])
        // Displays mercredi 10 avril 2024 06:30:00
    }
in
    Source

Torna alla tabella

Identificatore di formato di ora breve e data generale ("g")

L'identificatore di formato standard "g" rappresenta una combinazione degli schemi di data breve ("d") e ora breve ("t"), separati da uno spazio. Il testo risultante è interessato dalle informazioni di formattazione di impostazioni cultura specifiche.

La stringa di risultato è influenzata dalle informazioni di formattazione di impostazioni cultura specifiche.

Nell'esempio seguente viene usato l'identificatore di formato "g" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "g", Culture = ""]),
        // Displays 04/10/2024 06:30

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "g", Culture = "en-US"]),
        // Displays 4/10/2024 6:30 AM

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "g", Culture = "fr-BE"])
        // Displays 10-04-24 06:30
    }
in
    Source

Torna alla tabella

Identificatore di formato di ora estesa e data generale ("G")

L'identificatore di formato standard "G" rappresenta una combinazione degli schemi di data breve ("d") e ora estesa ("T"), separati da uno spazio. Il testo risultante è interessato dalle informazioni di formattazione di impostazioni cultura specifiche.

La stringa di risultato è influenzata dalle informazioni di formattazione di impostazioni cultura specifiche.

Nell'esempio seguente viene usato l'identificatore di formato "G" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "G", Culture = ""]),
        // Displays 04/10/2024 06:30:00

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "G", Culture = "en-US"]),
        // Displays 4/10/2024 6:30:00 AM

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "G", Culture = "nl-BE"])
        // Displays 10/04/2024 6:30:00
    }
in
    Source

Torna alla tabella

Identificatore di formato di round trip ("O", "o")

L'identificatore di formato standard "O" o "o" rappresenta una stringa di formato di data e ora personalizzata con uno schema che mantiene le informazioni sul fuso orario e crea una stringa di risultato conforme allo standard ISO 8601. Per i valori DateTimeZone , questo identificatore di formato è progettato per mantenere i valori di data, ora e fuso orario nel testo.

L'identificatore di formato standard "O" o "o" corrisponde all'identificatore di formato "aaaa'-'MM'-'dd'T'HH':'mm':'ss'. fffffffxxx" stringa di formato personalizzata per i valori DateTimeZone . In questo testo, le coppie di virgolette singole che delimitano singoli caratteri, ad esempio i trattini, i due punti e la lettera "T", indicano che il singolo carattere è un valore letterale che non può essere modificato. Gli apostrofi non vengono visualizzati nella stringa di output.

Identificatore di formato standard "O" o "o" (e "aaaa'-'MM'-'dd'T'HH':'mm':'ss'. fffffffffxxx" formato personalizzato) sfrutta i modi in cui ISO 8601 rappresenta le informazioni sul fuso orario per mantenere i valori DateTimeZone:

• Il componente del fuso orario di DateTimeZone.ToLocal valori di data e ora è un offset rispetto all'ora UTC ,ad esempio +01:00, -07:00.

• Il componente del fuso orario di DateTimeZone.ToUtc valori di data e ora usa +00,00 per rappresentare l'ora UTC.

Poiché l'identificatore di formato standard "O" o "o" è conforme a uno standard internazionale, l'operazione di formattazione o analisi che usa l'identificatore impiega sempre le impostazioni cultura invarianti e il calendario gregoriano.

Nell'esempio seguente viene usato l'identificatore di formato "o" per visualizzare una serie di valori DateTimeZone in un sistema nel fuso orario pacifico degli Stati Uniti.

let
    date1 = #datetimezone(2024, 6, 15, 13, 45, 30, 0, 0),
    Source =
    {
        Text.Format("#{0} (Unspecified) --> #{1}", {date1, DateTimeZone.ToText(date1, [Format = "O"])}),
        Text.Format("#{0} (Utc) --> #{1}", {date1, DateTimeZone.ToText(DateTimeZone.ToUtc(date1), [Format = "O"])}),
        Text.Format("#{0} (Local) --> #{1}", {date1, DateTimeZone.ToText(DateTimeZone.ToLocal(date1), [Format = "O"])})
    }
in
    Source

// The example displays the following output:
//    6/15/2024 1:45:30 PM +00:00 (Unspecified) --> 2024-06-15T13:45:30.0000000+00:00
//    6/15/2024 1:45:30 PM +00:00 (Utc) --> 2024-06-15T13:45:30.0000000+00:00
//    6/15/2024 1:45:30 PM +00:00 (Local) --> 2024-06-15T08:45:30.0000000-07:00

Nell'esempio seguente viene utilizzato l'identificatore di formato "o" per creare una stringa formattata e quindi viene ripristinato il valore di data e ora originale chiamando una routine di analisi di data e ora.

let
    // Round-trip a local time
    #"Origin Local Date" = DateTimeZone.ToLocal(
        #datetimezone(2024, 4, 10, 6, 30, 0, 0, 0)
    ),
    #"Local Date Text" = DateTimeZone.ToText(
        #"Origin Local Date", [Format = "o"]
    ),
    #"New Local Date" = DateTimeZone.FromText(#"Local Date Text"),
    #"Local Round Trip" = Text.Format(
        "Round-tripped #{0} Local to #{1} Local.", 
        {
            DateTimeZone.ToText(#"Origin Local Date"), 
            DateTimeZone.ToText(#"New Local Date")
        }
    ),

    // Round-trip a UTC time
    #"Origin UTC Date" = DateTimeZone.ToUtc(
        #datetimezone(2024, 4, 12, 9, 30, 0, 0, 0)
    ),
    #"UTC Date Text" = DateTimeZone.ToText(
        #"Origin UTC Date", [Format = "o"]
    ),
    #"New UTC Date" = DateTimeZone.FromText(#"UTC Date Text"),
    #"UTC Round Trip" = Text.Format(
        "Round-tripped #{0} UTC to #{1} UTC.", 
        {
            DateTimeZone.ToText(#"Origin UTC Date"), 
            DateTimeZone.ToText(#"New UTC Date")
        }
    ),

    // Round-trip an 18 hour offset time
    #"Origin Offset Date" = DateTimeZone.ToLocal(
        #datetimezone(2024, 4, 10, 6, 30, 0, 0, 0) + #duration(0, 18, 0, 0)
    ),
    #"Offset Date Text" = DateTimeZone.ToText(
        #"Origin Offset Date", [Format = "o"]
    ),
    #"New Offset Date" = DateTimeZone.FromText(#"Offset Date Text"),
    #"Offset Round Trip" = Text.Format(
        "Round-tripped #{0} to #{1}.", 
        {
            DateTimeZone.ToText(#"Origin Offset Date"), 
            DateTimeZone.ToText(#"New Offset Date")
        }
    ),

    #"Round Trip Results" = 
        {#"Local Round Trip", #"UTC Round Trip", #"Offset Round Trip"}
in
    #"Round Trip Results"

// The example displays the following output in Power Query Desktop:
//    Round-tripped 4/9/2024 11:30:00 PM -07:00 Local to 4/9/2024 11:30:00 PM -07:00 Local.
//    Round-tripped 4/12/2024 9:30:00 AM +00:00 UTC to 4/12/2024 9:30:00 AM +00:00 UTC.
//    Round-tripped 4/10/2024 5:30:00 PM -07:00 to 4/10/2024 5:30:00 PM -07:00.

// The example displays the following output in Power Query Online:
//    Round-tripped 4/10/2024 6:30:00 AM +00:00 Local to 4/10/2024 6:30:00 AM +00:00 Local.
//    Round-tripped 4/12/2024 9:30:00 AM +00:00 UTC to 4/12/2024 9:30:00 AM +00:00 UTC.
//    Round-tripped 4/11/2024 12:30:00 AM +00:00 to 4/11/2024 12:30:00 AM +00:00.

Torna alla tabella

Identificatore di formato RFC1123 ("R", "r")

L'identificatore di formato standard "R" o "r" rappresenta una stringa di formato di data e ora personalizzata non definita da impostazioni cultura specifiche. È sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato fornito. La stringa di formato personalizzata è "ddd, dd MMM yyyy HH':'mm':'ss 'GMT". Quando viene usato questo identificatore di formato standard, la formattazione o l'operazione di analisi usa sempre le impostazioni cultura invarianti.

Anche se lo standard RFC 1123 esprime un'ora come UTC (Coordinated Universal Time), l'operazione di formattazione non modifica il valore della data e dell'ora formattata. Pertanto, è necessario convertire il valore DateTime in UTC chiamando il metodo della funzione DateTimeZone.ToUtc prima di eseguire l'operazione di formattazione.

L'esempio seguente usa l'identificatore di formato "r" per visualizzare un valore di ora e data in un sistema nel fuso orario pacifico degli Stati Uniti (sette ore dietro l'ora UTC).

let
    date1 = #datetimezone(2024, 4, 10, 6, 30, 0, -7, 0),
    dateOffset = DateTimeZone.ToUtc(date1),
    Source = 
    {
        DateTimeZone.ToText(date1, [Format = "r"]),
        // Displays Wed, 10 Apr 2024 13:30:00 GMT

        DateTimeZone.ToText(dateOffset, [Format = "r"])
        // Displays Wed, 10 Apr 2024 13:30:00 GMT
    }
in
    Source

Torna alla tabella

Identificatore di formato ordinabile ("s")

L'identificatore di formato standard "s" rappresenta una stringa di formato di data e ora personalizzata che riflette uno standard definito (ISO 8601) ed è di sola lettura. Pertanto sarà sempre lo stesso, indipendentemente dalle impostazioni cultura usate o dal provider di formato fornito. La stringa di formato personalizzata è "yyyy'-'MM'-'dd'T'HH':'mm':'ss". L'identificatore di formato "s" ha lo scopo di produrre stringhe di risultati organizzate coerentemente in ordine crescente o decrescente, in base ai valori di data e ora.

Quando viene usato questo identificatore di formato standard, la formattazione o l'operazione di analisi usa sempre le impostazioni cultura invarianti.

Nell'esempio seguente viene usato l'identificatore di formato "s" per visualizzare un valore di data e ora in un sistema nel fuso orario pacifico degli Stati Uniti.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "s", Culture = "en-US"])
        // Displays 2024-04-10T06:30:00
    }
in
    Source

Torna alla tabella

Identificatore di formato ordinabile universale ("u")

L'identificatore di formato standard "u" rappresenta una stringa di formato di data e ora personalizzata che è sempre la stessa, indipendentemente dalle impostazioni cultura usate o dal provider di formato fornito. La stringa di formato personalizzata è "yyyy'-'MM'-'dd HH':'mm':'ss'Z". Lo schema riflette uno standard definito e la proprietà è di sola lettura. Quando viene usato questo identificatore di formato standard, la formattazione o l'operazione di analisi usa sempre le impostazioni cultura invarianti.

Anche se la stringa di risultato deve esprimere un'ora come UTC (Coordinated Universal Time), non viene eseguita alcuna conversione del valore DateTimeZone originale durante l'operazione di formattazione. Pertanto, è necessario convertire un valore DateTimeZone in formato UTC chiamando la funzione DateTimeZone.ToUtc prima di formattarla.

Nell'esempio seguente viene usato l'identificatore di formato "u" per visualizzare un valore di data e ora.

let
    date1 = #datetimezone(2024, 4, 10, 6, 30, 0, -7, 0),
    dateOffset = DateTimeZone.ToUtc(date1),
    Source =
    {
        DateTimeZone.ToText(dateOffset, [Format = "u"]),
        // Displays 2024-04-10 13:30:00Z
    }
in
    Source

Torna alla tabella

Formati ora

Questo gruppo include i formati seguenti:

• Identificatore di formato breve ("t")
• Identificatore di formato long time ("T")

Identificatore di formato di ora breve ("t")

L'identificatore di formato standard "t" rappresenta una stringa di formato di data e ora personalizzata definita dalle impostazioni cultura specificate. La stringa di formato personalizzata per le impostazioni cultura invarianti ad esempio è "HH:mm".

La stringa di risultato è influenzata dalle informazioni di formattazione di impostazioni cultura specifiche.

Nell'esempio seguente viene usato l'identificatore di formato "t" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "t", Culture = ""]),
        // Displays 06:30
        
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "t", Culture = "en-US"]),
        // Displays 6:30 AM

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "t", Culture = "es-ES"])
        // Displays 6:30
    }
in
    Source

Torna alla tabella

Identificatore di formato di ora estesa ("T")

L'identificatore di formato standard "T" rappresenta una stringa di formato di data e ora personalizzata definita dalle impostazioni cultura specifiche. La stringa di formato personalizzata per le impostazioni cultura invarianti ad esempio è "HH:mm:ss".

Nell'esempio seguente viene usato l'identificatore di formato "T" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "T", Culture = ""]),
        // Displays 06:30:00
        
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "T", Culture = "en-US"]),
        // Displays 6:30:00 AM

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "T", Culture = "es-ES"])
        // Displays 6:30:00
    }
in
    Source

Torna alla tabella

Formati di data parziale

Questo gruppo include i formati seguenti:

• Identificatore di formato month ("M", "m")
• Identificatore di formato year month ("Y", "y")

Identificatore di formato di mese ("M", "m")

L'identificatore di formato standard "M" o "m" rappresenta una stringa di formato di data e ora personalizzata definita dalle impostazioni cultura specifiche. La stringa di formato personalizzata per le impostazioni cultura invarianti ad esempio è "MMMM dd".

Nell'esempio seguente viene usato l'identificatore di formato "m" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "m", Culture = ""]),
        // Displays April 10
        
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "m", Culture = "en-US"]),
        // Displays April 10

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "m", Culture = "ms-MY"])
        // Displays 10 April
    }
in
    Source

Torna alla tabella

Identificatore di formato di mese e anno ("Y", "y")

L'identificatore di formato standard "Y" o "y" rappresenta una stringa di formato di data personalizzata definita da impostazioni cultura specifiche. La stringa di formato personalizzata per le impostazioni cultura invarianti ad esempio è "yyyy MMMM".

Nell'esempio seguente viene usato l'identificatore di formato "Y" per visualizzare un valore di data e ora.

let
    Source =
    {
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "Y", Culture = ""]),
        // Displays 2024 April
        
        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "Y", Culture = "en-US"]),
        // Displays April 2024

        DateTime.ToText(#datetime(2024, 4, 10, 6, 30, 0), [Format = "y", Culture = "af-ZA"])
        // Displays April 2024
    }
in
    Source

Torna alla tabella

Contenuto correlato

• Impatto delle impostazioni cultura sulla formattazione del testo
• Conversione dei tipi Date, Time, DateTime e DateTimeZone
• Funzioni di data
• Funzioni datetime
• Funzioni DateTimeZone
• Funzioni di ora
• Stringhe formato data e ora personalizzate