Operátor formátování - 3. část

V minulém díle jsme skončili ukázkou různých formátů data. Dnes si ukážeme, jak si můžeme vytvořit formát vlastní, pokud nám předdefinované nestačí. Vraťme se k mému oblíbenému ShortDatePattern. Uložíme si aktuální datum a čas do proměnné.

PS C:\> $d = Get-Date
PS C:\> $d

31. prosince 2008 22:32:33

PS C:\> "{0:d}" -f $d
31.12.2008
PS C:\> (Get-Culture).DateTimeFormat

ShortDatePattern : d.M.yyyy

0:d (standardní formát) reprezentuje zobrazení ve tvaru d.M.yyyy (uživatelský formát). V uživatelském formátu je význam znaků následující:

• d – den ve tvaru 31
  
• M – měsíc ve tvaru 12
  
• yyyy – rok ve tvaru 2008
  
• . – funguje jako oddělovač jednotlivých položek
  

Když si vyzkoušíte následující dva příklady

PS C:\> "{0:d}" -f $d
31.12.2008
PS C:\> "{0:d.M.yyyy}" -f $d
31.12.2008

dostanete naprosto shodný výsledek. V tomto případě je tedy jednodušší použít standardní formát a ušetřit sedm znaků, než si formát data vytvořit po svém. Pokud ovšem budete chtít například jiný oddělovač dne a měsíce, je dobré znát uživatelské formátování a potřebný výstup si vytvořit.

PS C:\> "{0:~d~ [M] (yyyy)}" -f $d
~31~ [12] (2008)

Jak PowerShell (.NET) pozná, zda d, které jsme zadali, je ShortDatePattern nebo uživatelské zobrazení dne? Existuje jednoduché pravidlo – pokud formátovací řetězec obsahuje více než jeden znak (počítá se i mezera!), je brán jako uživatelský formát, čili

PS C:\> "{0:d}" -f $d
31.12.2008
PS C:\> "{0:d }" -f $d
31

V následující části se podíváme na všechny formátovací řetězce. Pro snažší zapamatování jsem se snažil sdružit je do kategorií.

Den

• d – zobrazuje den jako číslo ve tvaru 1..31
  
• dd – zobrazuje den jako číslo ve tvaru 01..31 (přidává nulu v případě, že pořadové číslo dne je menší než 10).
  
• ddd – zobrazuje zkratku dne. Jak je definována můžete zjistit pomocí příkazu (Get-Culture).DateTimeFormat.AbbreviatedDayNames
• dddd – zobrazuje jméno dne, viz (Get-Culture).DateTimeFormat.DayNames
  

Ukažme si rovnou nějaké příklady

PS C:\> "{0:d}" -f $d
31.12.2008
PS C:\> "{0:d }" -f $d
31
PS C:\> "{0}" -f $d.day
31
PS C:\> "{0:dd}" -f $d
31
PS C:\> "{0:ddd}" -f $d
st
PS C:\> "{0:dddd}" -f $d
středa
PS C:\> (Get-Culture).DateTimeFormat | fl *DayNames

AbbreviatedDayNames : {ne, po, út, st...}
ShortestDayNames : {ne, po, út, st...}
DayNames : {neděle, pondělí, úterý, středa...}

Měsíc

• M – měsíc jako číslo ve tvaru 1..12
  
• MM – měsíc jako číslo ve tvaru 01..12
  
• MMM – zkratka měsíce dle (Get-Culture).DateTimeFormat.AbbreviatedMonthNames – zobrazení je ve tvaru římských číslic
  
• MMMM – jméno měsíce v plném tvaru, viz (Get-Culture).DateTimeFormat.MonthNames
  

PS C:\> "{0:M}" -f $d
31 prosince
PS C:\> "{0:M }" -f $d
12
PS C:\> "{0}" -f $d.Month
12
PS C:\> "{0:MM}" -f $d
12
PS C:\> "{0:MMM}" -f $d
XII
PS C:\> "{0:MMMM}" -f $d
prosinec
PS C:\> (Get-Culture).DateTimeFormat | fl *MonthNames

AbbreviatedMonthNames : {I, II, III, IV...}
MonthNames : {leden, únor, březen, duben...}

Nyní jsem již podruhé použil konstrukci, která se vám možná moc nelíbí. Jde o `0:M ` (s mezerou za znakem M). Z ukázek to není patrné, ale zvídavější povahy dospěly ke (správnému) názoru, že mezera navíc se nám projeví ve výstupním řetězci a občas nám to může vadit. Pojďme si to ověřit.

PS C:\> "{0:M }" -f $d
12
PS C:\> ("{0:M }" -f $d).length
3
PS C:\> Write-Host "|$($a[2])|"
| |

Mezera jak vyšitá :) Jak se tohoto jevu zbavit si ukážeme na konci dnešního článku. Do té doby budeme všechny jednopísmenné formátovací řetězce zapisovat s mezerou za znakem.

Ještě jedna malá odbočka před tím, než budeme pokračovat. V následujících příkladech budu v některých částech od aktuálního data odčítat určitý počet dní, hodin, … Pro Ty, kteří zatím moc nepracovali s třídou DateTime či příkazem Get-Date uvádím malou ukázku (za znaky ### bude vždy následovat komentář k příkazu).

PS C:\> $d | Get-Member Add* ### Zobrazíme všechny metody pracující s přičítáním času


TypeName: System.DateTime

Name MemberType Definition
---- ---------- ----------
Add Method System.DateTime Add(TimeSpan value)
AddDays Method System.DateTime AddDays(Double value)
AddHours Method System.DateTime AddHours(Double value)
AddMilliseconds Method System.DateTime AddMilliseconds(Double value)
AddMinutes Method System.DateTime AddMinutes(Double value)
AddMonths Method System.DateTime AddMonths(Int32 months)
AddSeconds Method System.DateTime AddSeconds(Double value)
AddTicks Method System.DateTime AddTicks(Int64 value)
AddYears Method System.DateTime AddYears(Int32 value)

PS C:\> "{0}" -f $d ### Vypíšeme aktuální stav proměnné d
31.12.2008 22:32:33
PS C:\> "{0}" -f $d.AddDays(1) ### Přičteme jeden den
1.1.2009 22:32:33
PS C:\> "{0}" -f $d.AddHours(2) ### Přičteme dvě hodiny
1.1.2009 0:32:33
PS C:\> ### V následujících příkazech budeme časové jednotky odčítat
PS C:\> "{0}" -f $d.AddDays(-366) ### Odečteme 366 dní (rok 2008 byl přestupný)
31.12.2007 22:32:33
PS C:\> "{0}" -f $d.AddSeconds(-611) ### A co třeba nějaký zapamatovatelný čas
31.12.2008 22:22:22

Důležité je z předchozích příkazů pochopit, že v čase můžeme jít i do minulosti.

Rok

• y – rok jako max. jedno nebo dvouciferné číslo.
  
• yy – rok jako dvouciferné číslo.
  
• yyy – zobrazí rok jako minimálně trojciferné číslo. Pokud má rok více než tři významové číslice jsou i ty zobrazeny ve výsledku.
  
• yyyy – zobrazí rok jako čtyřciferné číslo. Pokud má rok méně než čtyři čísla je zleva doplněn nulami.
  
• yyyyy – zobrazí rok jako pěticiferné číslo. Pokud má rok méně než pět číslel je zleva doplněn nulami.
  

PS C:\> "{0:y}" -f $d
prosinec 2008
PS C:\> "{0:y }" -f $d
8
PS C:\> "{0:yy}" -f $d
08
PS C:\> "{0:yyy}" -f $d
2008
PS C:\> "{0:yyyy}" -f $d
2008
PS C:\> "{0:yyyyy}" -f $d
02008
PS C:\> "{0:yyy}" -f $d.AddYears(-2000)
008
PS C:\> "{0:yyyyy}" -f $d.AddYears(-2000)
00008

Hodina

• h – zobrazuje hodinu jako číslo z intervalu 1..12. Jedná se tedy o zobrazení dvanáctihodinového cyklu.
  
• hh – zobrazuje hodinu jako číslo z intervalu 01..12.
  
• H – zobrazuje hodinu jako číslo z intervalu 0..23. Zobrazuje dvacetičtyřhodinový formát.
  
• HH – zobrazuje hodinu jako číslo z intervalu 00..23.
  

PS C:\> "{0:h}" -f $d
Exception retrieving string: "Input string was not in a correct format."
At line:1 char:11
+ "{0:h}" -f <<<< $d

PS C:\> "{0:h }" -f $d.AddHours(-1)
9
PS C:\> "{0:hh}" -f $d.AddHours(-1)
09
PS C:\> "{0:H }" -f $d.AddHours(-1)
21
PS C:\> "{0:HH}" -f $d.AddHours(-1)
21

V případě znaku h byla vyhozena výjimka z toho důvodu, že pro standardní formátování data neexistuje formátovací řetězec h. Tu samou chybu obdržíte, pokud zkusíte např. znak x.

Minuta

• m – minuta ve tvaru 0..59
  
• mm – minuta ve tvaru 00..59
  

PS C:\> "{0:m}" -f $d
31 prosince
PS C:\> "{0:m }" -f $d
32
PS C:\> "{0:m }" -f $d.AddMinutes(-30)
2
PS C:\> "{0:mm}" -f $d.AddMinutes(-30)
02
PS C:\> "{0:mm}" -f $d
32

Sekunda

• s – sekunda ve tvaru 0..59
  
• ss – sekunda ve tvaru 00..59
  

Celá idea už je nyní asi jasná a proto uvedeme pouze jeden příklad.

PS C:\> "{0:ss}" -f $d
33

Při zobrazování času můžeme jít až na úroveň milisekund. Formátovacím řetězcem je znak f (a F). V současné době máme v proměnné d uložen čas, který má v sobě hodnotu 290ms. Pro názornost budeme tedy v následujících příkladech odečítat 200 ms.

PS C:\> "{0:H:mm:s:f}" -f $d.AddMilliseconds(-200)
22:32:33:0
PS C:\> "{0:H:mm:s:F}" -f $d.AddMilliseconds(-200)
22:32:33:
PS C:\> "{0:H:mm:s:ff}" -f $d.AddMilliseconds(-200)
22:32:33:09
PS C:\> "{0:H:mm:s:FF}" -f $d.AddMilliseconds(-200)
22:32:33:09
PS C:\> "{0:H:mm:s:fff}" -f $d.AddMilliseconds(-200)
22:32:33:090
PS C:\> "{0:H:mm:s:FFF}" -f $d.AddMilliseconds(-200)
22:32:33:09

V zobrazení milisekund je tedy vidět malá změna při zobrazování – zobrazujeme vždy hodnoty „zleva“, což ale dává smysl, protože potřebujeme znát významově nejvyšší číslici. V zobrazování můžeme jít až na úroveň sedmi f (fffffff, FFFFFFF), ale z hlediska přesnosti to nemá význam (dle MSDN je přesnost hodin většiny systémů Windows 10-15ms).

„Speciální“ formátovací řetězce
.NET zavádí ještě několik dalších znaků, které můžeme při zobrazení data a času použít.

• g – zobrazuje éru, čili n. l. pro současný rok
  
• K, z – zobrazuje informace o časové zóně
  
• t, tt – označení dopoledne/odpoledne dle System.Globalization.DateTimeFormatInfo.AMDesignator a System.Globalization.DateTimeFormatInfo.PMDesignator
  
• : / - zastupují separátory času a datumu definované dle System.Globalization.DateTimeFormatInfo.TimeSeparator a System.Globalization.DateTimeFormatInfo.DateSeparator
  
• “ ‘ – zobrazí text uvedený v uvozovkách
  
• % - zobrazí výsledek formátovacího řetězce braného jako uživatelský formát. Jinými slovy od této doby můžete použít místo znaku mezery za formátovacím řetězcem použít procento před, např. %d.
  
• \ - zobrazí znak zapsaný za lomítkem, např. \h
  
• jakýkoli jiný znak způsobí vyhození výjimky.

PS C:\> (Get-Culture).DateTimeFormat

AMDesignator : dop.
PMDesignator : odp.
DateSeparator : .
TimeSeparator : :

PS C:\> "{0:d}" -f $d
31.12.2008
PS C:\> "{0:d }" -f $d
31
PS C:\> "{0:%d}" -f $d
31
PS C:\> ("{0:%d}" -f $d).length
2

PS C:\> "{0:%g}" -f $d
n. l.

PS C:\> "{0:d \d 'd'}" -f $d
31 d d

Po předcházejcích ukázkách už zřejmě chápete, proč pomocí “{0:d}” –f $d dostaneme výsledek 31.12.2008. Takže se pojďme podívat na trochu složitější příklad. Ve druhém díle jsme si ukazovali i univerzální setříditelný formát, který se zapisuje pomocí formátovacího řetězce u. Je tvořen následujícím způsobem:

PS C:\> "{0:u}" -f $d
2008-12-31 22:32:33Z
PS C:\> [System.Globalization.DateTimeFormatInfo]::CurrentInfo.UniversalSortableDateTimePattern
yyyy'-'MM'-'dd HH':'mm':'ss'Z'

Zleva doprava jsou postupně zobrazeny tyto údaje: rok ve čtyřčíselném formátu (2008), pomlčka (-), měsíc ve dvouciferném formátu (12), pomlčka (-), den ve dvouciferném formátu (31), mezera, hodiny ve čtyřiadvacetihodinovém dvouciferném formátu (22), minuty dvouciferně (32), sekundy dvouciferně (33), písmeno Z.

PS C:\> "Den: {0:%d}`nMesic: {1:%M}`nRok: {2:yyyy}`nJe tedy {0:%d}. {3} {2:yy}" -f $d, $d, $d, `
>> (Get-Culture).DateTimeFormat.MonthGenitiveNames[$d.Month-1]
>>
Den: 31
Mesic: 12
Rok: 2008
Je tedy 31. prosince 08

V předchozím příkladu jsem použil jednu dosud nezmíněnou vlastnost třídy DateTime – MonthGenitiveNames, výsledek je vidět ve výstupu.

Po pročtení toho dílu byste měli být schopni formátovat datum v jakémkoli tvaru. Jako vždy si můžete stáhnout zdrojové kódy. Nicméně i tak doporučuju si všechny příklady (i vaše vlastní vymyšlené) pěkně natlouct přes klávesnici. Jen tak vám přejdou do krve.