Formate für Daten und Zeiten

Mehrere Ruby-Klassen im Zusammenhang mit Zeit haben die Instanzmethode strftime, die eine formatierte Zeichenkette zurückgibt, die ein Datum oder eine Zeit ganz oder teilweise darstellt.

Jede dieser Methoden nimmt ein optionales Argument format entgegen, das null oder mehr eingebettete Formatangaben (siehe unten) enthält.

Jede dieser Methoden gibt die Zeichenkette zurück, die sich aus dem Ersetzen jeder im format eingebetteten Formatangabe durch eine Zeichenkettenform eines oder mehrerer Teile des Datums oder der Zeit ergibt.

Ein einfaches Beispiel

Time.now.strftime('%H:%M:%S') # => "14:02:07"

Eine Formatangabe hat die Form

%[flags][width]conversion

Sie besteht aus

Einem führenden Prozentzeichen.
Null oder mehr Flags (jedes ist ein Zeichen).
Ein optionaler Breitenangabe (eine Ganzzahl).
Ein Konvertierungsangabe (ein Zeichen).

Bis auf das führende Prozentzeichen ist der einzige erforderliche Teil die Konvertierungsangabe, also beginnen wir damit.

Konvertierungsangaben

Datum (Jahr, Monat, Tag)

%Y - Jahr inklusive Jahrhundert, mit Nullen aufgefüllt

Time.now.strftime('%Y')        # => "2022"
Time.new(-1000).strftime('%Y') # => "-1000" # Before common era.
Time.new(10000).strftime('%Y') # => "10000" # Far future.
Time.new(10).strftime('%Y')    # => "0010"  # Zero-padded by default.

%y - Jahr ohne Jahrhundert, im Bereich (0.99), mit Nullen aufgefüllt

Time.now.strftime('%y')    # => "22"
Time.new(1).strftime('%y') # => "01" # Zero-padded by default.

%C - Jahrhundert, mit Nullen aufgefüllt

Time.now.strftime('%C')        # => "20"
Time.new(-1000).strftime('%C') # => "-10" # Before common era.
Time.new(10000).strftime('%C') # => "100" # Far future.
Time.new(100).strftime('%C')   # => "01"  # Zero-padded by default.

%m - Monat des Jahres, im Bereich (1..12), mit Nullen aufgefüllt

Time.new(2022, 1).strftime('%m')  # => "01" # Zero-padded by default.
Time.new(2022, 12).strftime('%m') # => "12"

%B - Vollständiger Monatsname, großgeschrieben

Time.new(2022, 1).strftime('%B')  # => "January"
Time.new(2022, 12).strftime('%B') # => "December"

%b - Abgekürzter Monatsname, großgeschrieben

Time.new(2022, 1).strftime('%b')  # => "Jan"
Time.new(2022, 12).strftime('%h') # => "Dec"

%h - Dasselbe wie %b.

%d - Tag des Monats, im Bereich (1..31), mit Nullen aufgefüllt

Time.new(2002, 1, 1).strftime('%d')  # => "01"
Time.new(2002, 1, 31).strftime('%d') # => "31"

%e - Tag des Monats, im Bereich (1..31), mit Leerzeichen aufgefüllt

Time.new(2002, 1, 1).strftime('%e')  # => " 1"
Time.new(2002, 1, 31).strftime('%e') # => "31"

%j - Tag des Jahres, im Bereich (1..366), mit Nullen aufgefüllt

Time.new(2002, 1, 1).strftime('%j')   # => "001"
Time.new(2002, 12, 31).strftime('%j') # => "365"

Zeit (Stunde, Minute, Sekunde, Bruchteile von Sekunden)

%H - Stunde des Tages, im Bereich (0..23), mit Nullen aufgefüllt

Time.new(2022, 1, 1, 1).strftime('%H')  # => "01"
Time.new(2022, 1, 1, 13).strftime('%H') # => "13"

%k - Stunde des Tages, im Bereich (0..23), mit Leerzeichen aufgefüllt

Time.new(2022, 1, 1, 1).strftime('%k')  # => " 1"
Time.new(2022, 1, 1, 13).strftime('%k') # => "13"

%I - Stunde des Tages, im Bereich (1..12), mit Nullen aufgefüllt

Time.new(2022, 1, 1, 1).strftime('%I')  # => "01"
Time.new(2022, 1, 1, 13).strftime('%I') # => "01"

%l - Stunde des Tages, im Bereich (1..12), mit Leerzeichen aufgefüllt

Time.new(2022, 1, 1, 1).strftime('%l')  # => " 1"
Time.new(2022, 1, 1, 13).strftime('%l') # => " 1"

%P - Meridian-Indikator, Kleinbuchstaben

Time.new(2022, 1, 1, 1).strftime('%P')  # => "am"
Time.new(2022, 1, 1, 13).strftime('%P') # => "pm"

%p - Meridian-Indikator, Großbuchstaben

Time.new(2022, 1, 1, 1).strftime('%p')  # => "AM"
Time.new(2022, 1, 1, 13).strftime('%p') # => "PM"

%M - Minute der Stunde, im Bereich (0..59), mit Nullen aufgefüllt
```
Time.new(2022, 1, 1, 1, 0, 0).strftime('%M') # => "00"
```

%S - Sekunde der Minute im Bereich (0..59), mit Nullen aufgefüllt

Time.new(2022, 1, 1, 1, 0, 0, 0).strftime('%S') # => "00"

%L - Millisekunde der Sekunde, im Bereich (0..999), mit Nullen aufgefüllt
```
Time.new(2022, 1, 1, 1, 0, 0, 0).strftime('%L') # => "000"
```

%N - Gebrochene Sekunden, Standardbreite ist 9 Ziffern (Nanosekunden)

t = Time.now       # => 2022-06-29 07:10:20.3230914 -0500
t.strftime('%N')   # => "323091400"                  # Default.

Verwenden Sie Breitenangaben, um Einheiten anzupassen

t.strftime('%3N')  # => "323"                      # Milliseconds.
t.strftime('%6N')  # => "323091"                   # Microseconds.
t.strftime('%9N')  # => "323091400"                # Nanoseconds.
t.strftime('%12N') # => "323091400000"             # Picoseconds.
t.strftime('%15N') # => "323091400000000"          # Femptoseconds.
t.strftime('%18N') # => "323091400000000000"       # Attoseconds.
t.strftime('%21N') # => "323091400000000000000"    # Zeptoseconds.
t.strftime('%24N') # => "323091400000000000000000" # Yoctoseconds.

%s - Anzahl der Sekunden seit der Epoche

Time.now.strftime('%s') # => "1656505136"

Zeitzone

%z - Zeitzone als Stunden- und Minutenversatz von UTC
```
Time.now.strftime('%z') # => "-0500"
```

%Z - Zeitzonenname (plattformabhängig)

Time.now.strftime('%Z') # => "Central Daylight Time"

Wochentag

%A - Vollständiger Wochentagsname

Time.now.strftime('%A') # => "Wednesday"

%a - Abgekürzter Wochentagsname
```
Time.now.strftime('%a') # => "Wed"
```

%u - Tag der Woche, im Bereich (1..7), Montag ist 1

t = Time.new(2022, 6, 26) # => 2022-06-26 00:00:00 -0500
t.strftime('%a')          # => "Sun"
t.strftime('%u')          # => "7"

%w - Tag der Woche, im Bereich (0..6), Sonntag ist 0

t = Time.new(2022, 6, 26) # => 2022-06-26 00:00:00 -0500
t.strftime('%a')          # => "Sun"
t.strftime('%w')          # => "0"

Wochennummer

%U - Wochennummer des Jahres, im Bereich (0..53), mit Nullen aufgefüllt, wobei jede Woche am Sonntag beginnt

t = Time.new(2022, 6, 26) # => 2022-06-26 00:00:00 -0500
t.strftime('%a')          # => "Sun"
t.strftime('%U')          # => "26"

%W - Wochennummer des Jahres, im Bereich (0..53), mit Nullen aufgefüllt, wobei jede Woche am Montag beginnt

t = Time.new(2022, 6, 26) # => 2022-06-26 00:00:00 -0500
t.strftime('%a')          # => "Sun"
t.strftime('%W')          # => "25"

Wochen-Daten

Siehe ISO 8601 Wochen-Daten.

t0 = Time.new(2023, 1, 1) # => 2023-01-01 00:00:00 -0600
t1 = Time.new(2024, 1, 1) # => 2024-01-01 00:00:00 -0600

%G - Wochenbasiertes Jahr

t0.strftime('%G') # => "2022"
t1.strftime('%G') # => "2024"

%g - Wochenbasiertes Jahr ohne Jahrhundert, im Bereich (0..99), mit Nullen aufgefüllt
```
t0.strftime('%g') # => "22"
t1.strftime('%g') # => "24"
```
%V - Wochennummer des wochenbasierten Jahres, im Bereich (1..53), mit Nullen aufgefüllt
```
t0.strftime('%V') # => "52"
t1.strftime('%V') # => "01"
```

Literale

%n - Zeilenumbruchzeichen “n”
```
Time.now.strftime('%n') # => "\n"
```
%t - Tabulatorzeichen “t”
```
Time.now.strftime('%t') # => "\t"
```
%% - Prozentzeichen ‘%’
```
Time.now.strftime('%%') # => "%"
```

Kurzbezeichner für Konvertierungen

Jeder Kurzbezeichner hier ist mit seinem entsprechenden Langbezeichner dargestellt.

%c - Datum und Zeit

Time.now.strftime('%c')             # => "Wed Jun 29 08:01:41 2022"
Time.now.strftime('%a %b %e %T %Y') # => "Wed Jun 29 08:02:07 2022"

%D - Datum

Time.now.strftime('%D')       # => "06/29/22"
Time.now.strftime('%m/%d/%y') # => "06/29/22"

%F - ISO 8601 Datum

Time.now.strftime('%F')       # => "2022-06-29"
Time.now.strftime('%Y-%m-%d') # => "2022-06-29"

%v - VMS Datum

Time.now.strftime('%v')         # => "29-JUN-2022"
Time.now.strftime('%e-%^b-%4Y') # => "29-JUN-2022"

%x - Dasselbe wie %D.
%X - Dasselbe wie %T.

%r - 12-Stunden-Zeit

Time.new(2022, 1, 1, 1).strftime('%r')           # => "01:00:00 AM"
Time.new(2022, 1, 1, 1).strftime('%I:%M:%S %p')  # => "01:00:00 AM"
Time.new(2022, 1, 1, 13).strftime('%r')          # => "01:00:00 PM"
Time.new(2022, 1, 1, 13).strftime('%I:%M:%S %p') # => "01:00:00 PM"

%R - 24-Stunden-Zeit

Time.new(2022, 1, 1, 1).strftime('%R')     # => "01:00"
Time.new(2022, 1, 1, 1).strftime('%H:%M')  # => "01:00"
Time.new(2022, 1, 1, 13).strftime('%R')    # => "13:00"
Time.new(2022, 1, 1, 13).strftime('%H:%M') # => "13:00"

%T - 24-Stunden-Zeit

Time.new(2022, 1, 1, 1).strftime('%T')        # => "01:00:00"
Time.new(2022, 1, 1, 1).strftime('%H:%M:%S')  # => "01:00:00"
Time.new(2022, 1, 1, 13).strftime('%T')       # => "13:00:00"
Time.new(2022, 1, 1, 13).strftime('%H:%M:%S') # => "13:00:00"

%+ (nicht unterstützt in Time#strftime) - Datum und Zeit

DateTime.now.strftime('%+')
# => "Wed Jun 29 08:31:53 -05:00 2022"
DateTime.now.strftime('%a %b %e %H:%M:%S %Z %Y')
# => "Wed Jun 29 08:32:18 -05:00 2022"

Flags

Flags können bestimmte Formatierungen beeinflussen.

Mehrere Flags können mit einer einzelnen Konvertierung angegeben werden; die Reihenfolge spielt keine Rolle.

Auffüll-Flags

0 - Mit Nullen auffüllen

Time.new(10).strftime('%0Y') # => "0010"

_ - Mit Leerzeichen auffüllen

Time.new(10).strftime('%_Y') # => "  10"

- - Nicht auffüllen
```
Time.new(10).strftime('%-Y') # => "10"
```

Groß-/Kleinschreibungs-Flags

^ - Ergebnis großschreiben

Time.new(2022, 1).strftime('%B')  # => "January" # No casing flag.
Time.new(2022, 1).strftime('%^B') # => "JANUARY"

# - Ergebnis umkehren (Groß-/Kleinschreibung tauschen)

Time.now.strftime('%p')  # => "AM"
Time.now.strftime('%^p') # => "AM"
Time.now.strftime('%#p') # => "am"

Zeitzonen-Flags

: - Zeitzone als durch Doppelpunkte getrennte Stunden und Minuten darstellen
```
Time.now.strftime('%:z')  # => "-05:00"
```
:: - Zeitzone als durch Doppelpunkte getrennte Stunden, Minuten und Sekunden darstellen
```
Time.now.strftime('%::z') # => "-05:00:00"
```

Breitenangaben

Die Ganzzahl-Breitenangabe gibt eine minimale Breite für die zurückgegebene Zeichenkette an.

Time.new(2002).strftime('%Y')       # => "2002"     # No width specifier.
Time.new(2002).strftime('%10Y')     # => "0000002002"
Time.new(2002, 12).strftime('%B')   # => "December" # No width specifier.
Time.new(2002, 12).strftime('%10B') # => "  December"
Time.new(2002, 12).strftime('%3B')  # => "December" # Ignored if too small.

Spezialisierte Formatzeichenketten

Hier sind einige spezialisierte Formatzeichenketten, die jeweils auf einem externen Standard basieren.

HTTP-Format

Das HTTP-Datumsformat basiert auf RFC 2616 und behandelt Daten im Format '%a, %d %b %Y %T GMT'

d = Date.new(2001, 2, 3) # => #<Date: 2001-02-03>
# Return HTTP-formatted string.
httpdate = d.httpdate    # => "Sat, 03 Feb 2001 00:00:00 GMT"
# Return new date parsed from HTTP-formatted string.
Date.httpdate(httpdate)  # => #<Date: 2001-02-03>
# Return hash parsed from HTTP-formatted string.
Date._httpdate(httpdate)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"GMT", :offset=>0}

RFC 3339-Format

Das RFC 3339-Datumsformat basiert auf RFC 3339

d = Date.new(2001, 2, 3) # => #<Date: 2001-02-03>
# Return 3339-formatted string.
rfc3339 = d.rfc3339      # => "2001-02-03T00:00:00+00:00"
# Return new date parsed from 3339-formatted string.
Date.rfc3339(rfc3339)    # => #<Date: 2001-02-03>
# Return hash parsed from 3339-formatted string.
Date._rfc3339(rfc3339)
# => {:year=>2001, :mon=>2, :mday=>3, :hour=>0, :min=>0, :sec=>0, :zone=>"+00:00", :offset=>0}

RFC 2822-Format

Das RFC 2822-Datumsformat basiert auf RFC 2822 und behandelt Daten im Format '%a, %-d %b %Y %T %z']

d = Date.new(2001, 2, 3) # => #<Date: 2001-02-03>
# Return 2822-formatted string.
rfc2822 = d.rfc2822      # => "Sat, 3 Feb 2001 00:00:00 +0000"
# Return new date parsed from 2822-formatted string.
Date.rfc2822(rfc2822)    # => #<Date: 2001-02-03>
# Return hash parsed from 2822-formatted string.
Date._rfc2822(rfc2822)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"+0000", :offset=>0}

JIS X 0301-Format

Das JIS X 0301-Format beinhaltet den japanischen Äranamen und behandelt Daten im Format '%Y-%m-%d' mit dem ersten Buchstaben des romanisierten Äranamens vorangestellt

d = Date.new(2001, 2, 3) # => #<Date: 2001-02-03>
# Return 0301-formatted string.
jisx0301 = d.jisx0301    # => "H13.02.03"
# Return new date parsed from 0301-formatted string.
Date.jisx0301(jisx0301)  # => #<Date: 2001-02-03>
# Return hash parsed from 0301-formatted string.
Date._jisx0301(jisx0301) # => {:year=>2001, :mon=>2, :mday=>3}

ISO 8601-Formatangaben

Dieser Abschnitt zeigt Formatangaben, die mit ISO 8601 kompatibel sind. Details zu verschiedenen Formaten finden Sie unter den Links.

Beispiele in diesem Abschnitt gehen von Folgendem aus:

t = Time.now # => 2022-06-29 16:49:25.465246 -0500

Daten

Siehe ISO 8601 Daten.

Jahre:

Einfaches Jahr (YYYY)
```
t.strftime('%Y') # => "2022"
```

Erweitertes Jahr (±YYYYY)

t.strftime('+%5Y') # => "+02022"
t.strftime('-%5Y') # => "-02022"

Kalenderdaten:

Einfaches Datum (YYYYMMDD)
```
t.strftime('%Y%m%d') # => "20220629"
```

Erweitertes Datum (YYYY-MM-DD)

t.strftime('%Y-%m-%d') # => "2022-06-29"

Reduziertes erweitertes Datum (YYYY-MM)
```
t.strftime('%Y-%m') # => "2022-06"
```

Wochen-Daten:

Einfaches Datum (YYYYWww oder YYYYWwwD)

t.strftime('%Y%Ww')   # => "202226w"
t.strftime('%Y%Ww%u') # => "202226w3"

Erweitertes Datum (YYYY-Www oder <tt>YYYY-Www-D<tt>)

t.strftime('%Y-%Ww')    # => "2022-26w"
t.strftime('%Y-%Ww-%u') # => "2022-26w-3"

Ordinaldaten:

Einfaches Datum (YYYYDDD)
```
t.strftime('%Y%j') # => "2022180"
```
Erweitertes Datum (YYYY-DDD)
```
t.strftime('%Y-%j') # => "2022-180"
```

Zeiten

Siehe ISO 8601 Zeiten.

Zeiten

Einfache Zeit (Thhmmss.sss, Thhmmss, Thhmm oder Thh)

t.strftime('T%H%M%S.%L') # => "T164925.465"
t.strftime('T%H%M%S')    # => "T164925"
t.strftime('T%H%M')      # => "T1649"
t.strftime('T%H')        # => "T16"

Erweiterte Zeit (Thh:mm:ss.sss, Thh:mm:ss oder Thh:mm)

t.strftime('T%H:%M:%S.%L') # => "T16:49:25.465"
t.strftime('T%H:%M:%S')    # => "T16:49:25"
t.strftime('T%H:%M')       # => "T16:49"

Zeitzonen-Deskriptoren:
- Zeitzone (time repräsentiert eine gültige Zeit, hh repräsentiert eine gültige 2-stellige Stunde und mm repräsentiert eine gültige 2-stellige Minute)
  - Einfache Zeitzone (time±hhmm, time±hh oder timeZ)
```
t.strftime('T%H%M%S%z')              # => "T164925-0500"
t.strftime('T%H%M%S%z').slice(0..-3) # => "T164925-05"
t.strftime('T%H%M%SZ')               # => "T164925Z"
```
  - Erweiterte Zeitzone (time±hh:mm)
```
t.strftime('T%H:%M:%S%z') # => "T16:49:25-0500"
```
- Siehe auch

Kombinierte Datum und Zeit

Siehe ISO 8601 Kombinierte Darstellungen von Datum und Zeit.

Eine ISO 8601 kombinierte Datums- und Zeitdarstellung kann jedes ISO 8601 Datum und jede ISO 8601 Zeit sein, getrennt durch den Buchstaben T.

Für die relevanten strftime-Formate siehe Daten und Zeiten oben.