Udostępnij za pośrednictwem

Standardowe ciągi formatu daty i godziny

  • Artykuł

Standardowy ciąg formatu daty i godziny używa pojedynczego znaku jako specyfikatora formatu, aby zdefiniować tekstową reprezentację wartości godziny i daty. Dowolny ciąg formatu daty i godziny zawierający więcej niż jeden znak, w tym biały znak, jest interpretowany jako niestandardowy ciąg formatu daty i godziny. Ciąg formatu standardowego lub niestandardowego może służyć do definiowania reprezentacji tekstu, która wynika z operacji formatowania.

Tabela specyfikatorów formatu

W poniższej tabeli opisano standardowe specyfikatory formatu daty i godziny.

Specyfikator formatu opis Przykłady
„d” Wzorzec daty krótkiej.

Więcej informacji: Specyfikator formatu daty krótkiej ("d").		 2009-06-15T13:45:30 -> 6/15/2009 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 (fr-FR)

2009-06-15T13:45:30 -> 2009/06/15 (ja-JP)
„D” Wzorzec daty długiej.

Więcej informacji: Specyfikator formatu daty długiej ("D").		 2009-06-15T13:45:30 —> poniedziałek, 15 czerwca 2009 r. (en-US)

2009-06-15T13:45:30 -> понедельник, 15 июня 2009 г. (ru-RU)

2009-06-15T13:45:30 -> Montag, 15. Juni 2009 (de-DE)
„f” Wzorzec pełnej daty/godziny (godzina krótka).

Więcej informacji: Specyfikator formatu pełnej daty krótkiej ("f").		 2009-06-15T13:45:30 -> poniedziałek, 15 czerwca 2009 13:45 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45 (sv-SE)

2009-06-15T13:45:30 -> Δευτιρα, 15 Ιουνίου 2009 1:45 μμ (el-GR)
„F” Wzorzec pełnej daty/godziny (godzina długa).

Więcej informacji: Specyfikator formatu daty pełnej daty długiej ("F").		 2009-06-15T13:45:30 -> poniedziałek, 15 czerwca 2009 1:45:30 (en-US)

2009-06-15T13:45:30 -> den 15 juni 2009 13:45:30 (sv-SE)

2009-06-15T13:45:30 -> Δευτιρα, 15 Ιουνίου 2009 1:45:30 μμ (el-GR)
„g” Wzorzec ogólnej daty/godziny (godzina krótka).

Więcej informacji: Specyfikator formatu daty ogólnej daty krótkiej ("g").		 2009-06-15T13:45:30 -> 6/15/2009 1:45 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45 (zh-CN)
„G” Wzorzec ogólnej daty/godziny (godzina długa).

Więcej informacji: Specyfikator formatu daty ogólnej daty długiej ("G").		 2009-06-15T13:45:30 -> 6/15/2009 1:45:30 (en-US)

2009-06-15T13:45:30 -> 15/06/2009 13:45:30 (es-ES)

2009-06-15T13:45:30 -> 2009/6/15 13:45:30 (zh-CN)
„M”, „m” Wzorzec miesiąc/dzień.

Więcej informacji: Specyfikator formatu miesiąca ("M", "m").		 2009-06-15T13:45:30 —> 15 czerwca (en-US)

2009-06-15T13:45:30 -> 15. juni (da-DK)

2009-06-15T13:45:30 -> 15 Juni (id-ID)
„O”, „o” wzorzec daty/godziny w obie strony.

Więcej informacji: Specyfikator formatu round-trip ("O", "o").		 2009-06-15T13:45:30 (lokalny) -> 2009-06-15T13:45:30.0000000-07:00

2009-06-15T13:45:30 (utc) -> 2009-06-15T13:45:30.0000000+00:00

2009-06-15T13:45:30 (nieokreślony) -> 2009-06-15T13:45:30.0000000
„R”, „r” Wzorzec RFC1123.

Więcej informacji: specyfikator formatu RFC1123 ("R", "r").		 2009-06-15T13:45:30 -> Pon, 15 Czerwca 2009 13:45:30 GMT
„s” Wzorzec sortowalnej daty/godziny.

Więcej informacji: Specyfikator formatu sortowalnego ("s").		 2009-06-15T13:45:30 (lokalny) —> 2009-06-15T13:45:30

2009-06-15T13:45:30 (Utc) —> 2009-06-15T13:45:30
„t” Wzorzec godziny krótkiej.

Więcej informacji: Specyfikator formatu skróconego ("t").		 2009-06-15T13:45:30-1> :45 (en-US)

2009-06-15T13:45:30 -> 13:45 (hr-HR)

2009-06-15T13:45:30 -> 01:45 م (ar-EG)
„T” Wzorzec godziny długiej.

Więcej informacji: Specyfikator formatu długiego ("T").		 2009-06-15T13:45:30 -> 1:45:30 (en-US)

2009-06-15T13:45:30 -> 13:45:30 (hr-HR)

2009-06-15T13:45:30 -> 01:45:30 م (ar-EG)
„u” Wzorzec uniwersalnej sortowalnej daty/godziny.

Więcej informacji: Specyfikator formatu uniwersalnego sortowania ("u").		 2009-06-15T13:45:30 -> 2009-06-15 13:45:30Z
„Y”, „y” Wzorzec roku i miesiąca.

Więcej informacji: Specyfikator formatu miesiąca roku ("Y").		 2009-06-15T13:45:30 —> czerwiec 2009 (en-US)

2009-06-15T13:45:30 -> juni 2009 (da-DK)

2009-06-15T13:45:30 -> Juni 2009 (id-ID)
Jakikolwiek inny pojedynczy znak Nieznany specyfikator. Zgłasza błąd wyrażenia w czasie wykonywania.

Jak działają standardowe ciągi formatu

W operacji formatowania ciąg formatu standardowego jest po prostu aliasem ciągu formatu niestandardowego. Zaletą użycia aliasu w celu odwołania się do ciągu formatu niestandardowego jest to, że ciąg formatu niestandardowego może być różny, mimo że alias pozostaje niezmienny. Jest to ważne, ponieważ ciągi reprezentujące wartości daty i godziny są zazwyczaj różne w zależności od kultury. Na przykład ciąg formatu standardowego „d” wskazuje, że wartość daty i godziny zostanie wyświetlona przy użyciu wzorca daty krótkiej. Ten wzorzec dla niezmiennej kultury to „MM/dd/yyyy”. Dla kultury fr-FR jest to „dd/MM/yyyy”. Dla kultury ja-JP jest to „yyyy/MM/dd”.

Jeśli ciąg formatu standardowego w operacji formatowania jest mapowany na ciąg formatu niestandardowego danej kultury, aplikacja może definiować określoną kulturę, której ciągi formatu niestandardowego są używane na jeden z poniższych sposobów:

  • Można użyć domyślnej (bieżącej) kultury. W poniższym przykładzie data jest wyświetlana przy użyciu formatu daty krótkiej dla bieżącej kultury. Bieżącą kulturą jest w tym przypadku kultura en-US.

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

  • Możesz przekazać kulturę używaną do formatowania daty zgodnie z regułami tej konkretnej kultury. W poniższym przykładzie data jest wyświetlana przy użyciu formatu daty krótkiej dla kultury pt-BR.

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

W niektórych przypadkach ciąg formatu standardowego służy jako wygodny skrót dla dłuższego ciągu formatu niestandardowego, który jest niezmienny. Cztery ciągi formatu standardowego należą do tej kategorii: „O” (lub „o”), „R” (lub „r”), „s” i „u”. Te ciągi odpowiadają ciągom formatów niestandardowych, które są zdefiniowane przez niezmienną kulturę. Wytwarzają one reprezentacje wartości daty i godziny w postaci ciągu, które mają być identyczne dla różnych kultur. W poniższej tabeli przedstawiono informacje dotyczące tych czterech ciągów standardowych formatów daty i godziny.

Ciąg formatu standardowego Zdefiniowane przez Ciąg formatu niestandardowego
„O” lub „o” Brak yyyy'-'MM'-'dd'T'HH':'mm':'ss''. fffffffK
„R” lub „r” Specyfikacja IETF RFC 1123 ddd, dd MMM yyyy HH':'mm':'ss 'GMT'
„s” ISO 8601 yyyy'-'MM'-'dd'T'HH':'mm':'ss
„u” Sortowanie, ponieważ używa zer wiodących dla roku, miesiąca, dnia, godziny, minuty i sekundy yyyy'-'MM'-'dd HH':'mm':'ss'Z'

Ciągi formatu standardowego mogą być również używane w operacjach analizowania, które wymagają, aby ciąg wejściowy był dokładnie zgodny z określonym wzorcem dla operacji analizowania, aby operacja analizy powiodła się. Wiele standardowych ciągów formatu mapuje na wiele ciągów formatu niestandardowego, więc wartość daty i godziny może być reprezentowana w różnych formatach, a operacja analizowania nadal kończy się powodzeniem.

W poniższych sekcjach opisano standardowe specyfikatory formatu dla wartości Date, DateTime, DateTimeZone i Time.

Formaty dat

Ta grupa zawiera następujące formaty:

Specyfikator formatu daty krótkiej ("d")

Specyfikator formatu standardowego "d" reprezentuje niestandardowy format daty zdefiniowany przez określoną kulturę. Na przykład tekst formatu niestandardowego zwracany przez niezmienną kulturę to "MM/dd/rrrr".

W poniższym przykładzie użyto specyfikatora formatu "d", aby wyświetlić wartość daty.

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

Powrót do tabeli

Specyfikator formatu daty długiej ("D")

Specyfikator formatu standardowego "D" reprezentuje niestandardowy format daty zdefiniowany przez określoną kulturę. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „dddd, dd MMMM yyyy”.

W poniższym przykładzie użyto specyfikatora formatu „D”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Formaty daty i godziny

Ta grupa zawiera następujące formaty:

Specyfikator formatu daty pełnej daty krótkiej ("f")

Specyfikator formatu standardowego „f” reprezentuje kombinację wzorców daty długiej („D”) i godziny krótkiej („t”), rozdzielonych spacją.

Ciąg wynikowy ma wpływ na informacje o formatowaniu określonej kultury.

W poniższym przykładzie użyto specyfikatora formatu „f”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Specyfikator formatu daty pełnej daty długiej ("F")

Specyfikator formatu standardowego "F" reprezentuje niestandardowy format daty i godziny zdefiniowany przez określoną kulturę. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „dddd, dd MMMM yyyy HH:mm:ss”.

Ciąg wynikowy ma wpływ na informacje o formatowaniu określonej kultury.

W poniższym przykładzie użyto specyfikatora formatu „F”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Specyfikator formatu daty ogólnej daty krótkiej ("g")

Specyfikator formatu standardowego „g” reprezentuje kombinację wzorców daty krótkiej („g”) i godziny krótkiej („t”), rozdzielonych spacją. Wynikowy tekst ma wpływ na informacje o formatowaniu określonej kultury.

Ciąg wynikowy ma wpływ na informacje o formatowaniu określonej kultury.

W poniższym przykładzie użyto specyfikatora formatu „g”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Specyfikator formatu daty ogólnej daty długiej ("G")

Specyfikator formatu standardowego „G” reprezentuje kombinację wzorców daty krótkiej („d”) i godziny długiej („T”), rozdzielonych spacją. Wynikowy tekst ma wpływ na informacje o formatowaniu określonej kultury.

Ciąg wynikowy ma wpływ na informacje o formatowaniu określonej kultury.

W poniższym przykładzie użyto specyfikatora formatu „G”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Specyfikator formatu round-trip ("O", "o")

Specyfikator formatu standardowego "O" lub "o" reprezentuje niestandardowy ciąg formatu daty i godziny przy użyciu wzorca, który zachowuje informacje o strefie czasowej i emituje ciąg wynikowy zgodny z normą ISO 8601. W przypadku wartości DateTimeZone ten specyfikator formatu jest przeznaczony do zachowywania wartości daty, godziny i strefy czasowej w tekście.

Specyfikator formatu standardowego "O" lub "o" odpowiada "yyyy'-'MM'-'dd'T'HH':'mm'ss'". Ciąg formatu niestandardowego fffffffxxx dla wartości DateTimeZone . W tym tekście pary pojedynczych znaków cudzysłowu rozdzielające poszczególne znaki, takie jak łączniki, dwukropki i litera "T", wskazują, że pojedynczy znak jest literałem, którego nie można zmienić. Apostrofy nie są wyświetlane w ciągu wyjściowym.

Specyfikator formatu standardowego "O" lub "o" (i "yyyy'-'MM'-dd'T'HH':'mm'ss'". Format niestandardowy fffffffxxx) wykorzystuje sposób, w jaki iso 8601 reprezentuje informacje o strefie czasowej w celu zachowania wartości DateTimeZone:

  • Składnik strefy czasowej wartości daty i godziny DateTimeZone.ToLocal jest przesunięciem z utc (na przykład +01:00, -07:00).

  • Składnik strefy czasowej DateTimeZone.ToUtc wartości daty i godziny używa wartości +00,00 do reprezentowania czasu UTC.

Ponieważ specyfikator formatu standardowego "O" lub "o" jest zgodny ze standardem międzynarodowym, operacja formatowania lub analizowania używająca specyfikatora zawsze używa niezmiennej kultury i kalendarza gregoriańskiego.

W poniższym przykładzie użyto specyfikatora formatu "o", aby wyświetlić serię wartości DateTimeZone w systemie w strefie czasowej Pacyfik USA.

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

Uwaga

Wartość zwrócona przez DateTimeZone.ToLocal zależy od tego, czy używasz dodatku Power Query na komputerze lokalnym, czy w trybie online. Na przykład w powyższym przykładzie w systemie w strefie czasowej Pacyfik USA program Power Query Desktop zwraca -07:00czas lokalny , ponieważ odczytuje czas ustawiony na komputerze lokalnym. Jednak usługa Power Query Online zwraca +00:00 , ponieważ odczytuje czas ustawiony na maszynach wirtualnych w chmurze, które są ustawione na utc.

W poniższym przykładzie użyto specyfikatora formatu "o", aby utworzyć sformatowany ciąg, a następnie przywróci oryginalną wartość daty i godziny, wywołując procedurę analizowania daty i godziny.

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.

Powrót do tabeli

Specyfikator formatu RFC1123 ("R", "r")

Specyfikator formatu standardowego "R" lub "r" reprezentuje niestandardowy ciąg formatu daty i godziny, który nie jest zdefiniowany przez określoną kulturę. Zawsze jest to samo, niezależnie od używanej kultury lub dostarczonego dostawcy formatu. Ciąg formatu niestandardowego to „ddd, dd MMM yyyy HH':'mm':'ss 'GMT'”. Gdy jest używany ten specyfikator formatu standardowego, w operacji formatowania lub analizowania zawsze jest używana niezmienna kultura.

Mimo że standard RFC 1123 wyraża godzinę jako uniwersalny czas koordynowany (UTC), operacja formatowania nie modyfikuje wartości sformatowanej daty i godziny. W związku z tym należy przekonwertować wartość DateTime na UTC, wywołując metodę funkcji DateTimeZone.ToUtc przed wykonaniem operacji formatowania.

W poniższym przykładzie użyto specyfikatora formatu "r", aby wyświetlić wartość godziny i daty w systemie w strefie czasowej Pacyfik USA (siedem godzin za 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

Powrót do tabeli

Specyfikator formatu sortowalnego ("s")

Specyfikator formatu standardowego "s" reprezentuje niestandardowy ciąg formatu daty i godziny, który odzwierciedla zdefiniowany standard (ISO 8601) i jest tylko do odczytu. Dlatego też zawsze jest taki sam, niezależnie od używanej kultury oraz dostarczonego dostawcy formatów. Ciąg formatu niestandardowego to „yyyy'-'MM'-'dd'T'HH':'mm':'ss”. Celem specyfikatora formatu "s" jest wygenerowanie ciągów wyników, które sortują spójnie w kolejności rosnącej lub malejącej na podstawie wartości daty i godziny.

Gdy jest używany ten specyfikator formatu standardowego, w operacji formatowania lub analizowania zawsze jest używana niezmienna kultura.

W poniższym przykładzie użyto specyfikatora formatu "s", aby wyświetlić wartość daty i godziny w systemie w strefie czasowej Pacyfik USA.

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

Powrót do tabeli

Specyfikator formatu uniwersalnego sortowania ("u")

Specyfikator formatu standardowego "u" reprezentuje niestandardowy ciąg formatu daty i godziny, który jest zawsze taki sam, niezależnie od używanej kultury lub dostarczonego dostawcy formatu. Ciąg formatu niestandardowego to „yyyy'-'MM'-'dd HH':'mm':'ss'Z'”. Wzorzec odzwierciedla zdefiniowany standard, a właściwość jest tylko do odczytu. Gdy jest używany ten specyfikator formatu standardowego, w operacji formatowania lub analizowania zawsze jest używana niezmienna kultura.

Mimo że ciąg wynikowy powinien wyrazić czas jako uniwersalny czas koordynowany (UTC), podczas operacji formatowania nie jest wykonywana konwersja oryginalnej wartości DateTimeZone . W związku z tym należy przekonwertować wartość DateTimeZone na utc, wywołując funkcję DateTimeZone.ToUtc przed jego sformatowaniem.

W poniższym przykładzie użyto specyfikatora formatu „u”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Formaty czasu

Ta grupa zawiera następujące formaty:

Specyfikator formatu czasowego ("t")

Specyfikator formatu standardowego "t" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez określoną kulturę. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „HH:mm”.

Ciąg wynikowy ma wpływ na informacje o formatowaniu określonej kultury.

W poniższym przykładzie użyto specyfikatora formatu „t”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Specyfikator formatu długiego ("T")

Specyfikator formatu standardowego "T" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez określoną kulturę. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „HH:mm:ss”.

W poniższym przykładzie użyto specyfikatora formatu „T”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Częściowe formaty dat

Ta grupa zawiera następujące formaty:

Specyfikator formatu miesiąca ("M", "m")

Specyfikator formatu standardowego "M" lub "m" reprezentuje niestandardowy ciąg formatu daty i godziny zdefiniowany przez określoną kulturę. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „MMMM dd”.

W poniższym przykładzie użyto specyfikatora formatu „m”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Specyfikator formatu miesiąca roku ("Y", "y")

Specyfikator formatu standardowego "Y" lub "y" reprezentuje niestandardowy ciąg formatu daty zdefiniowany przez określoną kulturę. Na przykład ciąg formatu niestandardowego dla niezmiennej kultury to „yyyy MMMM”.

W poniższym przykładzie użyto specyfikatora formatu „y”, aby wyświetlić wartość daty i godziny.

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

Powrót do tabeli

Powiązana zawartość