Reťazce štandardného formátu dátumu a času

Reťazec štandardného formátu dátumu a času používa jeden znak ako špecifikátor formátu na definovanie textového vyjadrenia hodnoty času a dátumu. Akýkoľvek reťazec formátu dátumu a času, ktorý obsahuje viac ako jeden znak vrátane prázdneho priestoru, sa interpretuje ako vlastný reťazec formátu dátumu a času. Na definovanie textového vyjadrenia, ktoré je výsledkom operácie formátovania, možno použiť reťazec štandardného alebo vlastného formátu.

Tabuľka špecifikácií formátu

Nasledujúca tabuľka popisuje špecifikátory štandardného formátu dátumu a času.

Ako fungujú reťazce štandardného formátu

Pri operácii formátovania je reťazec štandardného formátu iba aliasom vlastného reťazca formátu. Výhodou použitia aliasu na odkazovanie na vlastný reťazec formátu je, že hoci alias zostáva nemenný, samotný vlastný reťazec formátu sa môže líšiť. Je to dôležité, pretože vyjadrenia reťazcov hodnôt dátumu a času sa zvyčajne líšia podľa kultúry. Napríklad reťazec štandardného formátu "d" označuje, že hodnota dátumu a času sa má zobraziť pomocou vzoru krátkeho dátumu. Pre invariantnú jazykovú verziu je tento vzor "MM/dd/rrrr". Pre jazykovú verziu fr-FR je to "dd/MM/rrrr". Pre jazykovú verziu ja-JP je to "yyyy/MM/dd".

Ak reťazec štandardného formátu v rámci operácie formátovania mapuje k vlastnému reťazcu formátu konkrétnej jazykovej verzie, vaša aplikácia môže definovať konkrétnu kultúru, ktorej vlastné reťazce formátu sa používajú jedným z týchto spôsobov:

• Môžete použiť predvolenú (alebo aktuálnu) jazykovú verziu. Nasledujúci príklad zobrazuje dátum pomocou krátkeho formátu dátumu aktuálnej jazykovej verzie. V tomto prípade je aktuálnou jazykovou verziou en-US.

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

• V prípade jazykovej verzie, ktorá sa používa na formátovanie dátumu, môžete prejsť podľa pravidiel danej špecifickej jazykovej verzie. V nasledujúcom príklade sa zobrazí dátum pomocou formátu krátkeho dátumu pt-BR kultúry.

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

V niektorých prípadoch reťazec štandardného formátu slúži ako praktická skratka pre dlhší vlastný reťazec formátu, ktorý je nemenný. Do tejto kategórie patria štyri reťazce štandardného formátu: "O" (alebo "o"), "R" (alebo "r"), "s" a "u". Tieto reťazce zodpovedajú reťazcom vlastného formátu definovaným invariantnej jazykovou verziou. Vytvárajú reťazcové vyjadrenia hodnôt dátumu a času, ktoré sú určené na to, aby boli identické medzi kultúrami. Nasledujúca tabuľka poskytuje informácie o týchto štyroch reťazcoch štandardného formátu dátumu a času.

Reťazce štandardného formátu možno použiť aj pri analýze operácií, ktoré vyžadujú, aby vstupný reťazec presne zodpovedal konkrétnemu vzoru pre operáciu analýzy na úspešné dokončenie. Mnohé reťazce štandardného formátu sa priraďujú k viacerým reťazcom vlastného formátu, takže hodnota dátumu a času môže byť zastúpená v rôznych formátoch a operácia analýzy je stále úspešná.

Nasledujúce časti popisujú špecifikátory štandardného formátu pre hodnoty Dátum, Dátum a čas, Dátum a čas.

Formáty dátumov

Táto skupina obsahuje nasledujúce formáty:

• Špecifikácia formátu krátkeho dátumu (d)
• Špecifikácia formátu dlhého dátumu (D)

Špecifikácia formátu krátkeho dátumu (d)

Špecifikácia štandardného formátu d predstavuje vlastný formát dátumu definovaný konkrétnou jazykovou verziou. Napríklad text vlastného formátu vrátený invariantou jazykovou verziou je MM/dd/rrrr.

Nasledujúci príklad používa špecifikátor formátu d na zobrazenie hodnoty dátumu.

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

Späť na tabuľku

Špecifikácia formátu dlhého dátumu (D)

Špecifikácia štandardného formátu D predstavuje vlastný formát dátumu definovaný konkrétnou jazykovou verziou. Napríklad vlastný reťazec formátu pre invariantnú kultúru je "dddd, dd MMMM rrrr".

Nasledujúci príklad používa špecifikátor formátu D na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Formáty dátumu a času

Táto skupina obsahuje nasledujúce formáty:

• Špecifikácia formátu úplného dátumu a času (f)
• Špecifikácia formátu dlhého dátumu a času (F)
• Špecifikácia formátu všeobecného dátumu a času ("g")
• Špecifikácia formátu dlhého dátumu a času ("G")
• Špecifikácia formátu zaokrúhlenia ("O", "o")
• Špecifikátor formátu RFC1123 ("R", "r")
• Špecifikátor formátu zoraditeľného ("s")
• Špecifikácia univerzálneho zoraditeľného formátu ("u")

Špecifikácia formátu úplného dátumu a času (f)

Špecifikácia štandardného formátu f predstavuje kombináciu vzorov dlhého dátumu ("D") a krátkeho času ("t"), oddelené medzerou.

Výsledný reťazec je ovplyvnený informáciami o formátovaní konkrétnej jazykovej verzie.

Nasledujúci príklad používa špecifikátor formátu f na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Špecifikácia formátu dlhého dátumu a času (F)

Špecifikácia štandardného formátu F predstavuje vlastný formát dátumu a času definovaný konkrétnou jazykovou verziou. Napríklad vlastný reťazec formátu pre invariantnú kultúru je "dddd, dd MMMM rrrr HH:mm:ss".

Výsledný reťazec je ovplyvnený informáciami o formátovaní konkrétnej jazykovej verzie.

Nasledujúci príklad používa špecifikátor formátu F na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Špecifikácia formátu všeobecného dátumu a času ("g")

Špecifikácia štandardného formátu "g" predstavuje kombináciu vzorov krátkeho dátumu ("d" a krátkeho času ("t"), oddelených medzerou. Výsledný text je ovplyvnený informáciami o formátovaní konkrétnej kultúry.

Výsledný reťazec je ovplyvnený informáciami o formátovaní konkrétnej jazykovej verzie.

Nasledujúci príklad používa špecifikátor formátu "g" na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Špecifikácia formátu dlhého dátumu a času ("G")

Špecifikácia štandardného formátu G predstavuje kombináciu vzorov krátkeho dátumu (d) a dlhého času (T), oddelených medzerou. Výsledný text je ovplyvnený informáciami o formátovaní konkrétnej kultúry.

Výsledný reťazec je ovplyvnený informáciami o formátovaní konkrétnej jazykovej verzie.

Nasledujúci príklad používa špecifikátor formátu G na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Špecifikácia formátu zaokrúhlenia ("O", "o")

Špecifikácia štandardného formátu "O" alebo "o" predstavuje vlastný reťazec formátu dátumu a času pomocou vzoru, ktorý zachováva informácie o časovom pásme a vydáva reťazec výsledku, ktorý je v súlade s normou ISO 8601. Pre hodnoty DateTimeZone je tento špecifikátor formátu určený na zachovanie hodnôt dátumu, času a časového pásma v texte.

Špecifikátor štandardného formátu "O" alebo "o" zodpovedá špecifikácii "yyyy'-MM'-'dd'T'HH':'mm':'ss'.' vlastný formát reťazca fffffffxxx pre hodnoty DateTimeZone . V tomto texte páry jednoduchých úvodzoviek, ktoré oddeľujú jednotlivé znaky, ako sú spojovníky, dvojbodky a písmeno "T", označujú, že jednotlivý znak je literál, ktorý nie je možné zmeniť. Apostrofy sa vo výstupnom reťazci nezobrazujú.

Špecifikátor štandardného formátu "O" alebo "o" (a "yyyy'-MM'-dd'T'HH':'mm':'ss'.' vlastný formát fffffffxxx) využíva spôsoby, akými funkcia ISO 8601 predstavuje informácie o časovom pásme na zachovanie hodnôt DateTimeZone:

• Komponent časového pásma DateTimeZone.ToLocal hodnoty dátumu a času je posun od UTC (napríklad +01:00, -07:00).

• Komponent časového pásma DateTimeZone.ToUtc hodnoty dátumu a času používa +00,00 na vyjadrenie UTC.

Keďže špecifikátor štandardného formátu "O" alebo "o" zodpovedá medzinárodnému štandardu, operácia formátovania alebo analýzy, ktorá používa špecifikátor, vždy používa invariantnú kultúru a gregoriánsky kalendár.

Nasledujúci príklad používa špecifikátor formátu "o" na zobrazenie radu hodnôt DateTimeZone v systéme v americkom tichomorskom časovom pásme.

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

Nasledujúci príklad používa špecifikátor formátu "o" na vytvorenie formátovaného reťazca a potom obnoví pôvodnú hodnotu dátumu a času volaním rutinnej analýzy dátumu a času.

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.

Späť na tabuľku

Špecifikátor formátu RFC1123 ("R", "r")

Špecifikácia štandardného formátu R alebo r predstavuje vlastný reťazec formátu dátumu a času, ktorý nie je definovaný konkrétnou jazykovou verziou. Vždy je rovnaký bez ohľadu na použitú jazykovú verziu alebo zadaného poskytovateľa formátu. Vlastný reťazec formátu je "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'. Pri použití tohto štandardného formátu špecifikátoru sa v rámci operácie formátovania alebo analýzy vždy používa invariantná kultúra.

Hoci štandard RFC 1123 vyjadruje čas ako koordinovaný svetový čas (UTC), operácia formátovania nemení hodnotu dátumu a času, ktorý je formátovaný. Preto musíte pred vykonaním operácie formátovania skonvertovať hodnotu DateTime na UTC zavolaním metódy funkcie DateTimeZone.ToUtc.

Nasledujúci príklad používa špecifikátor formátu r na zobrazenie hodnoty času a dátumu v systéme v americkom tichomorskom časovom pásme (sedem hodín 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

Späť na tabuľku

Špecifikátor formátu zoraditeľného ("s")

Špecifikácia štandardného formátu s predstavuje vlastný reťazec formátu dátumu a času, ktorý odráža definovanú normu (ISO 8601) a je iba na čítanie. Preto je vždy rovnaký bez ohľadu na použitú jazykovú verziu alebo poskytovateľa formátu. Vlastný reťazec formátu je "yyyy'-'MM'-dd'T'HH':'mm':'ss". Účelom špecifikátoru formátu s je vytvoriť výsledné reťazce, ktoré sa konzistentne zoraďujú vo vzostupnom alebo zostupnom poradí na základe hodnôt dátumu a času.

Pri použití tohto štandardného formátu špecifikátoru sa v rámci operácie formátovania alebo analýzy vždy používa invariantná kultúra.

Nasledujúci príklad používa špecifikátor formátu "s" na zobrazenie hodnoty dátumu a času v systéme v americkom tichomorskom časovom pásme.

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

Späť na tabuľku

Špecifikácia univerzálneho zoraditeľného formátu ("u")

Špecifikácia štandardného formátu u predstavuje vlastný reťazec formátu dátumu a času, ktorý je vždy rovnaký bez ohľadu na použitú jazykovú verziu alebo od zadaného poskytovateľa formátu. Vlastný reťazec formátu je "yyyy'-'MM'-dd HH':'mm':'ss'Z'". Vzor odzrkadľuje definovanú normu a vlastnosť je iba na čítanie. Pri použití tohto štandardného formátu špecifikátoru sa v rámci operácie formátovania alebo analýzy vždy používa invariantná kultúra.

Hoci reťazec výsledku by mal vyjadriť čas ako koordinovaný svetový čas (UTC), počas operácie formátovania sa nevykonáva žiadna konverzia pôvodnej hodnoty DateTimeZone . Preto musíte skonvertovať hodnotu DateTimeZone na UTC tak, že zavoláte funkciu DateTimeZone.ToUtc pred jej formátovaním.

Nasledujúci príklad používa špecifikátor formátu u na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Formáty času

Táto skupina obsahuje nasledujúce formáty:

• Špecifikátor formátu krátkeho času ("t")
• Špecifikácia formátu dlhého času (T)

Špecifikátor formátu krátkeho času ("t")

Špecifikácia štandardného formátu t predstavuje vlastný reťazec formátu dátumu a času, ktorý je definovaný zadanou jazykovou verziou. Napríklad vlastný reťazec formátu pre invariantná jazyková verzia je "HH:mm".

Výsledný reťazec je ovplyvnený informáciami o formátovaní konkrétnej jazykovej verzie.

Nasledujúci príklad používa špecifikátor formátu t na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Špecifikácia formátu dlhého času (T)

Špecifikácia štandardného formátu T predstavuje vlastný reťazec formátu dátumu a času, ktorý je definovaný konkrétnou jazykovou verziou. Napríklad vlastný reťazec formátu pre invariantná jazyková verzia je "HH:mm:ss".

Nasledujúci príklad používa špecifikátor formátu T na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Formáty čiastočných dátumov

Táto skupina obsahuje nasledujúce formáty:

• Špecifikátor formátu mesiaca ("M", "m")
• Špecifikátor formátu roka ("Y", "y")

Špecifikátor formátu mesiaca ("M", "m")

Špecifikácia štandardného formátu M alebo m predstavuje vlastný reťazec formátu dátumu a času, ktorý je definovaný konkrétnou jazykovou verziou. Napríklad vlastný reťazec formátu pre invariantnú kultúru je "MMMM dd".

Nasledujúci príklad používa špecifikátor formátu m na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Špecifikátor formátu roka ("Y", "y")

Špecifikátor štandardného formátu Y alebo y predstavuje vlastný reťazec formátu dátumu, ktorý je definovaný konkrétnou jazykovou verziou. Napríklad vlastný reťazec formátu pre invariantne jazykovú verziu je rrrr MMMM.

Nasledujúci príklad používa špecifikátor formátu y na zobrazenie hodnoty dátumu a času.

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

Späť na tabuľku

Súvisiaci obsah

• Ako kultúra ovplyvňuje formátovanie textu
• Konverzia typu Dátum, Čas, Dátum a Čas, a DátumČasovéPásoby
• Dátumové funkcie
• Funkcie DateTime
• Funkcie DateTimeZone
• Funkcie času
• Vlastné reťazce formátu dátumu a času