class Time

Gibt ein neues Time-Objekt zurück, das auf den gegebenen Argumenten basiert.

Das erforderliche Argument time kann eines von beiden sein:

• Ein Time-Objekt, dessen Wert die Grundlage für die zurückgegebene Zeit bildet; beeinflusst auch durch das optionale Schlüsselwortargument in: (siehe unten).

• Eine numerische Anzahl von Epoch-Sekunden für die zurückgegebene Zeit.

Beispiele

t = Time.new(2000, 12, 31, 23, 59, 59) # => 2000-12-31 23:59:59 -0600
secs = t.to_i                          # => 978328799
Time.at(secs)                          # => 2000-12-31 23:59:59 -0600
Time.at(secs + 0.5)                    # => 2000-12-31 23:59:59.5 -0600
Time.at(1000000000)                    # => 2001-09-08 20:46:40 -0500
Time.at(0)                             # => 1969-12-31 18:00:00 -0600
Time.at(-1000000000)                   # => 1938-04-24 17:13:20 -0500

Das optionale numerische Argument subsec und das optionale Symbolargument units arbeiten zusammen, um Nachkommastellen für die zurückgegebene Zeit anzugeben; das Argument units gibt die Einheiten für subsec an

• :millisecond: subsec in Millisekunden

  Time.at(secs, 0, :millisecond)     # => 2000-12-31 23:59:59 -0600
  Time.at(secs, 500, :millisecond)   # => 2000-12-31 23:59:59.5 -0600
  Time.at(secs, 1000, :millisecond)  # => 2001-01-01 00:00:00 -0600
  Time.at(secs, -1000, :millisecond) # => 2000-12-31 23:59:58 -0600
  

• :microsecond oder :usec: subsec in Mikrosekunden

  Time.at(secs, 0, :microsecond)        # => 2000-12-31 23:59:59 -0600
  Time.at(secs, 500000, :microsecond)   # => 2000-12-31 23:59:59.5 -0600
  Time.at(secs, 1000000, :microsecond)  # => 2001-01-01 00:00:00 -0600
  Time.at(secs, -1000000, :microsecond) # => 2000-12-31 23:59:58 -0600
  

• :nanosecond oder :nsec: subsec in Nanosekunden

  Time.at(secs, 0, :nanosecond)           # => 2000-12-31 23:59:59 -0600
  Time.at(secs, 500000000, :nanosecond)   # => 2000-12-31 23:59:59.5 -0600
  Time.at(secs, 1000000000, :nanosecond)  # => 2001-01-01 00:00:00 -0600
  Time.at(secs, -1000000000, :nanosecond) # => 2000-12-31 23:59:58 -0600
  

Das optionale Schlüsselwortargument in: zone gibt die Zeitzone für die zurückgegebene Zeit an

Time.at(secs, in: '+12:00') # => 2001-01-01 17:59:59 +1200
Time.at(secs, in: '-12:00') # => 2000-12-31 17:59:59 -1200

Für die Argumentformen von zone siehe Zeitzonenspezifizierer.

Analysiert date als HTTP-Datum, wie in RFC 2616 definiert, und konvertiert es in ein Time-Objekt.

Es wird ein ArgumentError ausgelöst, wenn date nicht RFC 2616-konform ist oder wenn die Klasse Time das angegebene Datum nicht darstellen kann.

Weitere Informationen zu diesem Format finden Sie unter httpdate.

require 'time'

Time.httpdate("Thu, 06 Oct 2011 02:26:12 GMT")
#=> 2011-10-06 02:26:12 UTC

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Siehe as_json.

Ähnlich wie Time.utc, außer dass das zurückgegebene Time-Objekt die lokale Zeitzone und nicht die UTC-Zeitzone hat.

# With seven arguments.
Time.local(0, 1, 2, 3, 4, 5, 6)
# => 0000-01-02 03:04:05.000006 -0600
# With exactly ten arguments.
Time.local(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# => 0005-04-03 02:01:00 -0600

Gibt ein neues Time-Objekt zurück, das auf den gegebenen Argumenten basiert, standardmäßig in der lokalen Zeitzone.

Ohne Positionsargumente wird der Wert von Time.now zurückgegeben.

Time.new # => 2021-04-24 17:27:46.0512465 -0500

Mit einem Zeichenkettenargument, das eine Zeit darstellt, wird ein neues Time-Objekt basierend auf dem gegebenen Argument in der lokalen Zeitzone zurückgegeben.

Time.new('2000-12-31 23:59:59.5')              # => 2000-12-31 23:59:59.5 -0600
Time.new('2000-12-31 23:59:59.5 +0900')        # => 2000-12-31 23:59:59.5 +0900
Time.new('2000-12-31 23:59:59.5', in: '+0900') # => 2000-12-31 23:59:59.5 +0900
Time.new('2000-12-31 23:59:59.5')              # => 2000-12-31 23:59:59.5 -0600
Time.new('2000-12-31 23:59:59.56789', precision: 3) # => 2000-12-31 23:59:59.567 -0600

Mit ein bis sechs Argumenten wird ein neues Time-Objekt basierend auf den gegebenen Argumenten in der lokalen Zeitzone zurückgegeben.

Time.new(2000, 1, 2, 3, 4, 5) # => 2000-01-02 03:04:05 -0600

Für die Positionsargumente (außer zone)

• year: Jahr, ohne Bereichsbeschränkungen

  Time.new(999999999)  # => 999999999-01-01 00:00:00 -0600
  Time.new(-999999999) # => -999999999-01-01 00:00:00 -0600
  

• month: Monat im Bereich (1..12) oder case-insensitiver 3-buchstabiger Monatsname

  Time.new(2000, 1)     # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 12)    # => 2000-12-01 00:00:00 -0600
  Time.new(2000, 'jan') # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 'JAN') # => 2000-01-01 00:00:00 -0600
  

• mday: Tag des Monats im Bereich (1..31)

  Time.new(2000, 1, 1)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 31) # => 2000-01-31 00:00:00 -0600
  

• hour: Stunde im Bereich (0..23) oder 24, wenn min, sec und usec Null sind

  Time.new(2000, 1, 1, 0)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 1, 23) # => 2000-01-01 23:00:00 -0600
  Time.new(2000, 1, 1, 24) # => 2000-01-02 00:00:00 -0600
  

• min: Minute im Bereich (0..59)

  Time.new(2000, 1, 1, 0, 0)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 1, 0, 59) # => 2000-01-01 00:59:00 -0600
  

• sec: Sekunde im Bereich (0…61)

  Time.new(2000, 1, 1, 0, 0, 0)  # => 2000-01-01 00:00:00 -0600
  Time.new(2000, 1, 1, 0, 0, 59) # => 2000-01-01 00:00:59 -0600
  Time.new(2000, 1, 1, 0, 0, 60) # => 2000-01-01 00:01:00 -0600
  

  sec kann ein Float oder Rational sein.

  Time.new(2000, 1, 1, 0, 0, 59.5)  # => 2000-12-31 23:59:59.5 +0900
  Time.new(2000, 1, 1, 0, 0, 59.7r) # => 2000-12-31 23:59:59.7 +0900
  

Diese Werte können sein

• Ganzzahlen, wie oben.

• Numerische Werte, die in Ganzzahlen konvertiert werden können

  Time.new(Float(0.0), Rational(1, 1), 1.0, 0.0, 0.0, 0.0)
  # => 0000-01-01 00:00:00 -0600
  

• Ganzzahlige Strings

  a = %w[0 1 1 0 0 0]
  # => ["0", "1", "1", "0", "0", "0"]
  Time.new(*a) # => 0000-01-01 00:00:00 -0600
  

Wenn das Positionsargument zone oder das Schlüsselwortargument in: angegeben wird, befindet sich das neue Time-Objekt in der angegebenen Zeitzone. Für die Formen des Arguments zone siehe Zeitzonenspezifizierer

Time.new(2000, 1, 1, 0, 0, 0, '+12:00')
# => 2000-01-01 00:00:00 +1200
Time.new(2000, 1, 1, 0, 0, 0, in: '-12:00')
# => 2000-01-01 00:00:00 -1200
Time.new(in: '-12:00')
# => 2022-08-23 08:49:26.1941467 -1200

Da in: als Schlüsselwortargument nur den Standardwert liefert, wird dieses Schlüsselwortargument stillschweigend ignoriert, wenn das erste Argument in einer einzelnen Zeichenkettenform Zeitzoneninformationen enthält.

Time.new('2000-01-01 00:00:00 +0100', in: '-0500').utc_offset  # => 3600

• precision: maximale effektive Ziffern im Nachkommastellenbereich, Standard ist 9. Mehr Ziffern werden abgeschnitten, wie auch bei anderen Operationen von Time. Wird ignoriert, es sei denn, das erste Argument ist eine Zeichenkette.

Erstellt ein neues Time-Objekt aus der aktuellen Systemzeit. Dies ist dasselbe wie Time.new ohne Argumente.

Time.now               # => 2009-06-24 12:39:54 +0900
Time.now(in: '+04:00') # => 2009-06-24 07:39:54 +0400

Für die Formen des Arguments zone siehe Zeitzonenspezifizierer.

Nimmt eine Zeichenfolgendarstellung einer Time entgegen und versucht, sie heuristisch zu parsen.

Diese Methode dient **nicht** als Validator. Wenn die Eingabezeichenkette nicht strikt mit gültigen Formaten übereinstimmt, erhalten Sie möglicherweise ein kryptisches Ergebnis. Sie sollten in Erwägung ziehen, stattdessen Time.strptime zu verwenden.

require 'time'

Time.parse("2010-10-31") #=> 2010-10-31 00:00:00 -0500

Fehlende Teile des Datums werden basierend auf dem aktuellen Datum abgeleitet.

require 'time'

# assuming the current date is "2011-10-31"
Time.parse("12:00") #=> 2011-10-31 12:00:00 -0500

Wir können das Datum, das zur Ableitung fehlender Elemente verwendet wird, ändern, indem wir ein zweites Objekt übergeben, das auf mon, day und year reagiert, wie z. B. Date, Time oder DateTime. Wir können auch unser eigenes Objekt verwenden.

require 'time'

class MyDate
  attr_reader :mon, :day, :year

  def initialize(mon, day, year)
    @mon, @day, @year = mon, day, year
  end
end

d  = Date.parse("2010-10-28")
t  = Time.parse("2010-10-29")
dt = DateTime.parse("2010-10-30")
md = MyDate.new(10,31,2010)

Time.parse("12:00", d)  #=> 2010-10-28 12:00:00 -0500
Time.parse("12:00", t)  #=> 2010-10-29 12:00:00 -0500
Time.parse("12:00", dt) #=> 2010-10-30 12:00:00 -0500
Time.parse("12:00", md) #=> 2010-10-31 12:00:00 -0500

Wenn ein Block gegeben ist, wird das in date beschriebene Jahr vom Block konvertiert. Dies ist speziell für die Behandlung von zweistelligen Jahren konzipiert. Wenn Sie beispielsweise alle zweistelligen Jahre vor 70 als das Jahr 2000+ behandeln wollten, könnten Sie dies schreiben

require 'time'

Time.parse("01-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
#=> 2001-10-31 00:00:00 -0500
Time.parse("70-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
#=> 1970-10-31 00:00:00 -0500

Wenn die oberen Komponenten der gegebenen Zeit fehlerhaft oder fehlend sind, werden sie mit denen von now ergänzt. Für die unteren Komponenten werden die Minimalwerte (1 oder 0) angenommen, wenn sie fehlerhaft oder fehlend sind. Zum Beispiel

require 'time'

# Suppose it is "Thu Nov 29 14:33:20 2001" now and
# your time zone is EST which is GMT-5.
now = Time.parse("Thu Nov 29 14:33:20 2001")
Time.parse("16:30", now)     #=> 2001-11-29 16:30:00 -0500
Time.parse("7/23", now)      #=> 2001-07-23 00:00:00 -0500
Time.parse("Aug 31", now)    #=> 2001-08-31 00:00:00 -0500
Time.parse("Aug 2000", now)  #=> 2000-08-01 00:00:00 -0500

Da es zahlreiche Konflikte bei lokal definierten Zeitzonenabkürzungen auf der ganzen Welt gibt, ist diese Methode nicht dazu gedacht, alle zu verstehen. Zum Beispiel wird die Abkürzung "CST" unterschiedlich verwendet als

-06:00 in America/Chicago,
-05:00 in America/Havana,
+08:00 in Asia/Harbin,
+09:30 in Australia/Darwin,
+10:30 in Australia/Adelaide,
etc.

Basierend auf dieser Tatsache versteht diese Methode nur die in RFC 822 definierten Zeitzonenabkürzungen und die Systemzeitzone, in der genannten Reihenfolge. (d. h. eine Definition in RFC 822 überschreibt die Systemzeitzonen-Definition.) Die Systemzeitzone wird aus Time.local(year, 1, 1).zone und Time.local(year, 7, 1).zone übernommen. Wenn die extrahierte Zeitzonenabkürzung keiner davon entspricht, wird sie ignoriert und die gegebene Zeit als lokale Zeit betrachtet.

Es wird ein ArgumentError ausgelöst, wenn Date._parse keine Informationen aus date extrahieren kann oder wenn die Klasse Time das angegebene Datum nicht darstellen kann.

Diese Methode kann als Ausfallsicherung für andere Parsing-Methoden verwendet werden, wie

Time.rfc2822(date) rescue Time.parse(date)
Time.httpdate(date) rescue Time.parse(date)
Time.xmlschema(date) rescue Time.parse(date)

Ein Fehler von Time.parse sollte jedoch überprüft werden.

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Analysiert date als Datum und Uhrzeit gemäß RFC 2822 und konvertiert es in ein Time-Objekt. Das Format ist identisch mit dem Datumsformat, das in RFC 822 definiert und durch RFC 1123 aktualisiert wurde.

Es wird ein ArgumentError ausgelöst, wenn date nicht RFC 2822-konform ist oder wenn die Klasse Time das angegebene Datum nicht darstellen kann.

Weitere Informationen zu diesem Format finden Sie unter rfc2822.

require 'time'

Time.rfc2822("Wed, 05 Oct 2011 22:26:12 -0400")
#=> 2010-10-05 22:26:12 -0400

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Funktioniert ähnlich wie parse, außer dass Sie anstelle der Verwendung einer Heuristik zur Erkennung des Formats der Eingabezeichenkette ein zweites Argument bereitstellen, das das Format der Zeichenkette beschreibt.

Löst ArgumentError aus, wenn das Datum oder Format ungültig ist.

Wenn ein Block gegeben ist, wird das in date beschriebene Jahr vom Block konvertiert. Zum Beispiel

Time.strptime(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}

Nachfolgend finden Sie eine Liste der Formatierungsoptionen

%a

Der abgekürzte Wochentagsname ("Sun")

%A

Der vollständige Wochentagsname ("Sunday")

%b

Der abgekürzte Monatsname ("Jan")

%B

Der vollständige Monatsname ("January")

%c

Die bevorzugte lokale Darstellung von Datum und Uhrzeit

%C

Jahrhundert (20 in 2009)

%d

Tag des Monats (01..31)

%D

Datum (%m/%d/%y)

%e

Tag des Monats, mit Leerzeichen aufgefüllt ( 1..31)

%F

Äquivalent zu %Y-%m-%d (das ISO 8601 Datumsformat)

%g

Die letzten beiden Ziffern des kommerziellen Jahres

%G

Das wochenbasierte Jahr gemäß ISO-8601 (Woche 1 beginnt am Montag und enthält den 4. Januar)

%h

Äquivalent zu %b

%H

Stunde des Tages, 24-Stunden-Format (00..23)

%I

Stunde des Tages, 12-Stunden-Format (01..12)

%j

Tag des Jahres (001..366)

%k

Stunde, 24-Stunden-Format, mit Leerzeichen aufgefüllt ( 0..23)

%l

Stunde, 12-Stunden-Format, mit Leerzeichen aufgefüllt ( 0..12)

%L

Millisekunde der Sekunde (000..999)

%m

Monat des Jahres (01..12)

%M

Minute der Stunde (00..59)

%n

Neue Zeile (n)

%N

Nachkommastellen

%p

Meridian-Indikator ("AM" oder "PM")

%P

Meridian-Indikator ("am" oder "pm")

%r

Uhrzeit, 12-Stunden (identisch mit %I:%M:%S %p)

%R

Uhrzeit, 24-Stunden (%H:%M)

%s

Anzahl der Sekunden seit 1970-01-01 00:00:00 UTC.

%S

Sekunde der Minute (00..60)

%t

Tabulatorzeichen (t)

%T

Uhrzeit, 24-Stunden (%H:%M:%S)

%u

Wochentag als Dezimalzahl, Montag ist 1. (1..7)

%U

Wochennummer des aktuellen Jahres, beginnend mit dem ersten Sonntag als erstem Tag der ersten Woche (00..53)

%v

VMS-Datum (%e-%b-%Y)

%V

Wochennummer des Jahres gemäß ISO 8601 (01..53)

%W

Wochennummer des aktuellen Jahres, beginnend mit dem ersten Montag als erstem Tag der ersten Woche (00..53)

%w

Wochentag (Sonntag ist 0, 0..6)

%x

Bevorzugte Darstellung für das Datum allein, keine Uhrzeit

%X

Bevorzugte Darstellung für die Uhrzeit allein, kein Datum

%y

Jahr ohne Jahrhundert (00..99)

%Y

Jahr, das das Jahrhundert enthalten kann, wenn angegeben

%z

Zeitzone als Stunden-Offset von UTC (z. B. +0900)

%Z

Zeitzonenname

%%

Literal " %"-Zeichen

%+

date(1) (%a %b %e %H:%M:%S %Z %Y)

require 'time'

Time.strptime("2000-10-31", "%Y-%m-%d") #=> 2000-10-31 00:00:00 -0500

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Gibt ein neues Time-Objekt zurück, das auf den gegebenen Argumenten basiert und sich in der UTC-Zeitzone befindet.

Wenn ein bis sieben Argumente angegeben werden, werden die Argumente wie in der ersten Aufrufsequenz oben interpretiert

Time.utc(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0)

Beispiele

Time.utc(2000)  # => 2000-01-01 00:00:00 UTC
Time.utc(-2000) # => -2000-01-01 00:00:00 UTC

Es gibt keine minimalen und maximalen Werte für das erforderliche Argument year.

Für die optionalen Argumente

• month: Monat im Bereich (1..12) oder case-insensitiver 3-buchstabiger Monatsname

  Time.utc(2000, 1)     # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 12)    # => 2000-12-01 00:00:00 UTC
  Time.utc(2000, 'jan') # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 'JAN') # => 2000-01-01 00:00:00 UTC
  

• mday: Tag des Monats im Bereich (1..31)

  Time.utc(2000, 1, 1)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 31) # => 2000-01-31 00:00:00 UTC
  

• hour: Stunde im Bereich (0..23) oder 24, wenn min, sec und usec Null sind

  Time.utc(2000, 1, 1, 0)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 23) # => 2000-01-01 23:00:00 UTC
  Time.utc(2000, 1, 1, 24) # => 2000-01-02 00:00:00 UTC
  

• min: Minute im Bereich (0..59)

  Time.utc(2000, 1, 1, 0, 0)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 0, 59) # => 2000-01-01 00:59:00 UTC
  

• sec: Sekunde im Bereich (0..59) oder 60, wenn usec Null ist

  Time.utc(2000, 1, 1, 0, 0, 0)  # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 0, 0, 59) # => 2000-01-01 00:00:59 UTC
  Time.utc(2000, 1, 1, 0, 0, 60) # => 2000-01-01 00:01:00 UTC
  

• usec: Mikrosekunde im Bereich (0..999999)

  Time.utc(2000, 1, 1, 0, 0, 0, 0)      # => 2000-01-01 00:00:00 UTC
  Time.utc(2000, 1, 1, 0, 0, 0, 999999) # => 2000-01-01 00:00:00.999999 UTC
  

Die Werte können

• Ganzzahlen, wie oben.

• Numerische Werte, die in Ganzzahlen konvertiert werden können

  Time.utc(Float(0.0), Rational(1, 1), 1.0, 0.0, 0.0, 0.0, 0.0)
  # => 0000-01-01 00:00:00 UTC
  

• Ganzzahlige Strings

  a = %w[0 1 1 0 0 0 0 0]
  # => ["0", "1", "1", "0", "0", "0", "0", "0"]
  Time.utc(*a) # => 0000-01-01 00:00:00 UTC
  

Wenn genau zehn Argumente gegeben sind, werden die Argumente wie in der zweiten oben genannten Aufrufsequenz interpretiert

Time.utc(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy)

wobei die dummy-Argumente ignoriert werden

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Time.utc(*a) # => 0005-04-03 02:01:00 UTC

Diese Form ist nützlich zum Erstellen eines Time-Objekts aus einem 10-Elemente-Array, das von Time.to_a zurückgegeben wird

t = Time.new(2000, 1, 2, 3, 4, 5, 6) # => 2000-01-02 03:04:05 +000006
a = t.to_a   # => [5, 4, 3, 2, 1, 2000, 0, 2, false, nil]
Time.utc(*a) # => 2000-01-02 03:04:05 UTC

Die beiden Formen haben ihre ersten sechs Argumente gemeinsam, wenn auch in unterschiedlicher Reihenfolge; die Bereiche dieser gemeinsamen Argumente sind für beide Formen gleich; siehe oben.

Löst eine Ausnahme aus, wenn die Anzahl der Argumente acht, neun oder größer als zehn ist.

Verwandt: Time.local.

Parst time als dateTime, das durch das XML-Schema definiert ist, und konvertiert es in ein Time-Objekt. Das Format ist eine eingeschränkte Version des Formats, das durch ISO 8601 definiert ist.

ArgumentError wird ausgelöst, wenn time nicht dem Format entspricht oder wenn die Time-Klasse die angegebene Zeit nicht darstellen kann.

Siehe xmlschema für weitere Informationen zu diesem Format.

require 'time'

Time.xmlschema("2011-10-05T22:26:12-04:00")
#=> 2011-10-05 22:26:12-04:00

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Gibt die Anzahl der Sekunden zurück, um die sich die angegebene Zeitzone von UTC unterscheidet.

Numeric-Zeitzonen, die Minuten enthalten, wie z. B. -10:00 oder +1330, funktionieren genauso wie einfachere, nur Stunden umfassende Zeitzonen wie -10 oder +13.

Textuelle Zeitzonen, die in ZoneOffset aufgeführt sind, werden ebenfalls unterstützt.

Wenn die Zeitzone keiner der oben genannten entspricht, prüft zone_offset, ob die lokale Zeitzone (sowohl mit als auch ohne mögliche Änderungen durch Sommerzeit) mit zone übereinstimmt. Die Angabe eines Wertes für year ändert das Jahr, das zur Ermittlung der lokalen Zeitzone verwendet wird.

Wenn zone_offset den Offset nicht ermitteln kann, wird nil zurückgegeben.

require 'time'

Time.zone_offset("EST") #=> -18000

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Gibt ein neues Time-Objekt zurück, dessen Wert die Summe des numerischen Wertes von self und des gegebenen numeric ist

t = Time.new(2000) # => 2000-01-01 00:00:00 -0600
t + (60 * 60 * 24) # => 2000-01-02 00:00:00 -0600
t + 0.5            # => 2000-01-01 00:00:00.5 -0600

Verwandt: Time#-.

Wenn numeric gegeben ist, wird ein neues Time-Objekt zurückgegeben, dessen Wert die Differenz des numerischen Wertes von self und numeric ist

t = Time.new(2000) # => 2000-01-01 00:00:00 -0600
t - (60 * 60 * 24) # => 1999-12-31 00:00:00 -0600
t - 0.5            # => 1999-12-31 23:59:59.5 -0600

Wenn other_time gegeben ist, wird ein Float zurückgegeben, dessen Wert die Differenz der numerischen Werte von self und other_time in Sekunden ist

t - t # => 0.0

Verwandt: Time#+.

Vergleicht self mit other_time; gibt zurück

• -1, wenn self kleiner als other_time ist.

• 0, wenn self gleich other_time ist.

• 1, wenn self größer als other_time ist.

• nil, wenn self und other_time nicht vergleichbar sind.

Beispiele

t = Time.now     # => 2007-11-19 08:12:12 -0600
t2 = t + 2592000 # => 2007-12-19 08:12:12 -0600
t <=> t2         # => -1
t2 <=> t         # => 1

t = Time.now     # => 2007-11-19 08:13:38 -0600
t2 = t + 0.1     # => 2007-11-19 08:13:38 -0600
t.nsec           # => 98222999
t2.nsec          # => 198222999
t <=> t2         # => -1
t2 <=> t         # => 1
t <=> t          # => 0

Die Methoden Time#as_json und Time.json_create können verwendet werden, um ein Time-Objekt zu serialisieren und zu deserialisieren; siehe Marshal.

Die Methode Time#as_json serialisiert self und gibt einen 2-Elemente-Hash zurück, der self repräsentiert

require 'json/add/time'
x = Time.now.as_json
# => {"json_class"=>"Time", "s"=>1700931656, "n"=>472846644}

Die Methode JSON.create deserialisiert einen solchen Hash und gibt ein Time-Objekt zurück

Time.json_create(x)
# => 2023-11-25 11:00:56.472846644 -0600

Gibt ein neues Time-Objekt zurück, dessen numerischer Wert größer oder gleich self ist, wobei die Sekunden auf die Präzision ndigits gekürzt werden

t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r)
t          # => 2010-03-30 05:43:25.123456789 UTC
t.ceil     # => 2010-03-30 05:43:26 UTC
t.ceil(2)  # => 2010-03-30 05:43:25.13 UTC
t.ceil(4)  # => 2010-03-30 05:43:25.1235 UTC
t.ceil(6)  # => 2010-03-30 05:43:25.123457 UTC
t.ceil(8)  # => 2010-03-30 05:43:25.12345679 UTC
t.ceil(10) # => 2010-03-30 05:43:25.123456789 UTC

t = Time.utc(1999, 12, 31, 23, 59, 59)
t              # => 1999-12-31 23:59:59 UTC
(t + 0.4).ceil # => 2000-01-01 00:00:00 UTC
(t + 0.9).ceil # => 2000-01-01 00:00:00 UTC
(t + 1.4).ceil # => 2000-01-01 00:00:01 UTC
(t + 1.9).ceil # => 2000-01-01 00:00:01 UTC

Verwandt: Time#floor, Time#round.

Gibt eine Zeichenkettenrepräsentation von self zurück, formatiert durch strftime('%a %b %e %T %Y') oder seine Kurzform strftime('%c'); siehe Formate für Daten und Zeiten

t = Time.new(2000, 12, 31, 23, 59, 59, 0.5)
t.ctime                      # => "Sun Dec 31 23:59:59 2000"
t.strftime('%a %b %e %T %Y') # => "Sun Dec 31 23:59:59 2000"
t.strftime('%c')             # => "Sun Dec 31 23:59:59 2000"

Verwandt: Time#to_s, Time#inspect

t.inspect                    # => "2000-12-31 23:59:59.5 +000001"
t.to_s                       # => "2000-12-31 23:59:59 +0000"

Gibt einen Hash der Namens/Wert-Paare zurück, der für Mustervergleiche verwendet werden kann. Mögliche Schlüssel sind: :year, :month, :day, :yday, :wday, :hour, :min, :sec, :subsec, :dst, :zone.

Mögliche Verwendungen

t = Time.utc(2022, 10, 5, 21, 25, 30)

if t in wday: 3, day: ..7  # uses deconstruct_keys underneath
  puts "first Wednesday of the month"
end
#=> prints "first Wednesday of the month"

case t
in year: ...2022
  puts "too old"
in month: ..9
  puts "quarter 1-3"
in wday: 1..5, month:
  puts "working day in month #{month}"
end
#=> prints "working day in month 10"

Beachten Sie, dass die Dekonstruktion per Muster auch mit Klassenprüfungen kombiniert werden kann.

if t in Time(wday: 3, day: ..7)
  puts "first Wednesday of the month"
end

Gibt true zurück, wenn self und other_time beides Time-Objekte mit exakt demselben Zeitwert sind.

Gibt ein neues Time-Objekt zurück, dessen numerischer Wert kleiner oder gleich self ist, wobei die Sekunden auf die Präzision ndigits gekürzt werden

t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r)
t           # => 2010-03-30 05:43:25.123456789 UTC
t.floor     # => 2010-03-30 05:43:25 UTC
t.floor(2)  # => 2010-03-30 05:43:25.12 UTC
t.floor(4)  # => 2010-03-30 05:43:25.1234 UTC
t.floor(6)  # => 2010-03-30 05:43:25.123456 UTC
t.floor(8)  # => 2010-03-30 05:43:25.12345678 UTC
t.floor(10) # => 2010-03-30 05:43:25.123456789 UTC

t = Time.utc(1999, 12, 31, 23, 59, 59)
t               # => 1999-12-31 23:59:59 UTC
(t + 0.4).floor # => 1999-12-31 23:59:59 UTC
(t + 0.9).floor # => 1999-12-31 23:59:59 UTC
(t + 1.4).floor # => 2000-01-01 00:00:00 UTC
(t + 1.9).floor # => 2000-01-01 00:00:00 UTC

Verwandt: Time#ceil, Time#round.

Gibt true zurück, wenn self einen Freitag repräsentiert, andernfalls false

t = Time.utc(2000, 1, 7) # => 2000-01-07 00:00:00 UTC
t.friday?                # => true

Verwandt: Time#saturday?, Time#sunday?, Time#monday?.

Gibt ein neues Time-Objekt zurück, das den Wert von self repräsentiert, konvertiert in eine gegebene Zeitzone; wenn zone nil ist, wird die lokale Zeitzone verwendet

t = Time.utc(2000)                    # => 2000-01-01 00:00:00 UTC
t.getlocal                            # => 1999-12-31 18:00:00 -0600
t.getlocal('+12:00')                  # => 2000-01-01 12:00:00 +1200

Für die Formen des Arguments zone siehe Zeitzonenspezifizierer.

Gibt den ganzzahligen Hash-Code für self zurück.

Verwandt: Object#hash.

Gibt die ganzzahlige Stunde des Tages für self zurück, im Bereich (0..23)

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.hour # => 3

Verwandt: Time#year, Time#mon, Time#min.

Gibt eine Zeichenkette zurück, die die Zeit als RFC 1123-Datum von HTTP-date gemäß RFC 2616 darstellt

day-of-week, DD month-name CCYY hh:mm:ss GMT

Beachten Sie, dass das Ergebnis immer UTC (GMT) ist.

require 'time'

t = Time.now
t.httpdate # => "Thu, 06 Oct 2011 02:26:12 GMT"

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Gibt eine Zeichenkettenrepräsentation von self mit Subsekunden zurück

t = Time.new(2000, 12, 31, 23, 59, 59, 0.5)
t.inspect # => "2000-12-31 23:59:59.5 +000001"

Verwandt: Time#ctime, Time#to_s

t.ctime   # => "Sun Dec 31 23:59:59 2000"
t.to_s    # => "2000-12-31 23:59:59 +0000"

Ohne Argument

• Gibt self zurück, wenn self eine lokale Zeit ist.

• Andernfalls wird ein neues Time-Objekt in der lokalen Zeitzone des Benutzers zurückgegeben

  t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
  t.localtime                         # => 2000-01-01 14:15:01 -0600
  

Mit dem Argument zone wird das neue Time-Objekt zurückgegeben, das durch Konvertierung von self in die gegebene Zeitzone erstellt wird

t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
t.localtime("-09:00")               # => 2000-01-01 11:15:01 -0900

Für die Formen des Arguments zone siehe Zeitzonenspezifizierer.

Gibt den ganzzahligen Tag des Monats für self zurück, im Bereich (1..31)

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.mday # => 2

Verwandt: Time#year, Time#hour, Time#min.

Gibt die ganzzahlige Minute der Stunde für self zurück, im Bereich (0..59)

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.min # => 4

Verwandt: Time#year, Time#mon, Time#sec.

Gibt den ganzzahligen Monat des Jahres für self zurück, im Bereich (1..12)

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.mon # => 1

Verwandt: Time#year, Time#hour, Time#min.

Gibt true zurück, wenn self einen Montag repräsentiert, andernfalls false

t = Time.utc(2000, 1, 3) # => 2000-01-03 00:00:00 UTC
t.monday?                # => true

Verwandt: Time#tuesday?, Time#wednesday?, Time#thursday?.

Gibt eine Zeichenkette zurück, die die Zeit als Datum und Uhrzeit gemäß RFC 2822 darstellt

day-of-week, DD month-name CCYY hh:mm:ss zone

wobei zone [+-]hhmm ist.

Wenn self eine UTC-Zeit ist, wird -0000 als Zone verwendet.

require 'time'

t = Time.now
t.rfc2822  # => "Wed, 05 Oct 2011 22:26:12 -0400"

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Gibt ein neues Time-Objekt zurück, dessen numerischer Wert dem von self entspricht, wobei der Sekundenwert auf die Präzision ndigits gerundet wird

t = Time.utc(2010, 3, 30, 5, 43, 25.123456789r)
t          # => 2010-03-30 05:43:25.123456789 UTC
t.round    # => 2010-03-30 05:43:25 UTC
t.round(0) # => 2010-03-30 05:43:25 UTC
t.round(1) # => 2010-03-30 05:43:25.1 UTC
t.round(2) # => 2010-03-30 05:43:25.12 UTC
t.round(3) # => 2010-03-30 05:43:25.123 UTC
t.round(4) # => 2010-03-30 05:43:25.1235 UTC

t = Time.utc(1999, 12,31, 23, 59, 59)
t                # => 1999-12-31 23:59:59 UTC
(t + 0.4).round  # => 1999-12-31 23:59:59 UTC
(t + 0.49).round # => 1999-12-31 23:59:59 UTC
(t + 0.5).round  # => 2000-01-01 00:00:00 UTC
(t + 1.4).round  # => 2000-01-01 00:00:00 UTC
(t + 1.49).round # => 2000-01-01 00:00:00 UTC
(t + 1.5).round  # => 2000-01-01 00:00:01 UTC

Verwandt: Time#ceil, Time#floor.

Gibt true zurück, wenn self einen Samstag repräsentiert, andernfalls false

t = Time.utc(2000, 1, 1) # => 2000-01-01 00:00:00 UTC
t.saturday?              # => true

Verwandt: Time#sunday?, Time#monday?, Time#tuesday?.

Gibt die ganzzahlige Sekunde der Minute für self zurück, im Bereich (0..60)

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.sec # => 5

Hinweis: Der Sekundenwert kann 60 sein, wenn eine Schaltsekunde vorhanden ist.

Verwandt: Time#year, Time#mon, Time#min.

Gibt eine Zeichenkettenrepräsentation von self zurück, die gemäß der gegebenen Zeichenkette format formatiert ist. Siehe Formate für Daten und Zeiten.

Gibt die exakten Nachkommastellen für self als Numeric (Integer oder Rational) zurück

t = Time.now # => 2022-07-11 15:11:36.8490302 -0500
t.subsec     # => (4245151/5000000)

Wenn die Nachkommastellen Null sind, wird die ganzzahlige Null zurückgegeben

t = Time.new(2000, 1, 1, 2, 3, 4) # => 2000-01-01 02:03:04 -0600
t.subsec                          # => 0

Gibt true zurück, wenn self einen Sonntag repräsentiert, andernfalls false

t = Time.utc(2000, 1, 2) # => 2000-01-02 00:00:00 UTC
t.sunday?                # => true

Verwandt: Time#monday?, Time#tuesday?, Time#wednesday?.

Gibt true zurück, wenn self einen Donnerstag repräsentiert, andernfalls false

t = Time.utc(2000, 1, 6) # => 2000-01-06 00:00:00 UTC
t.thursday?              # => true

Verwandt: Time#friday?, Time#saturday?, Time#sunday?.

Gibt ein 10-Elemente-Array von Werten zurück, das self repräsentiert

Time.utc(2000, 1, 1).to_a
# => [0,   0,   0,    1,   1,   2000, 6,    1,    false, "UTC"]
#    [sec, min, hour, day, mon, year, wday, yday, dst?,   zone]

Das zurückgegebene Array kann als Argument für Time.utc oder Time.local verwendet werden, um ein neues Time-Objekt zu erstellen.

Gibt ein Date-Objekt zurück, das self bezeichnet.

Gibt ein DateTime-Objekt zurück, das self bezeichnet.

Gibt den Wert von self als Float-Zahl Epoch-Sekunden zurück; Nachkommastellen sind enthalten.

Der gespeicherte Wert von self ist ein Rational, was bedeutet, dass der zurückgegebene Wert ungefähr sein kann

Time.utc(1970, 1, 1, 0, 0, 0).to_f         # => 0.0
Time.utc(1970, 1, 1, 0, 0, 0, 999999).to_f # => 0.999999
Time.utc(1950, 1, 1, 0, 0, 0).to_f         # => -631152000.0
Time.utc(1990, 1, 1, 0, 0, 0).to_f         # => 631152000.0

Verwandt: Time#to_i, Time#to_r.

Gibt den Wert von self als ganzzahlige Epoch-Sekunden zurück; Nachkommastellen werden abgeschnitten (nicht gerundet)

Time.utc(1970, 1, 1, 0, 0, 0).to_i         # => 0
Time.utc(1970, 1, 1, 0, 0, 0, 999999).to_i # => 0
Time.utc(1950, 1, 1, 0, 0, 0).to_i         # => -631152000
Time.utc(1990, 1, 1, 0, 0, 0).to_i         # => 631152000

Verwandt: Time#to_f Time#to_r.

Gibt einen JSON-String zurück, der self repräsentiert

require 'json/add/time'
puts Time.now.to_json

Ausgabe

{"json_class":"Time","s":1700931678,"n":980650786}

Gibt den Wert von self als exakte Anzahl von Epoch-Sekunden als Rational zurück;

Time.now.to_r # => (16571402750320203/10000000)

Verwandt: Time#to_f, Time#to_i.

Gibt eine Zeichenkettenrepräsentation von self zurück, ohne Nachkommastellen

t = Time.new(2000, 12, 31, 23, 59, 59, 0.5)
t.to_s    # => "2000-12-31 23:59:59 +0000"

Verwandt: Time#ctime, Time#inspect

t.ctime   # => "Sun Dec 31 23:59:59 2000"
t.inspect # => "2000-12-31 23:59:59.5 +000001"

Gibt self zurück.

Gibt true zurück, wenn self einen Dienstag repräsentiert, andernfalls false

t = Time.utc(2000, 1, 4) # => 2000-01-04 00:00:00 UTC
t.tuesday?               # => true

Verwandt: Time#wednesday?, Time#thursday?, Time#friday?.

Gibt true zurück, wenn self eine Zeit in UTC (GMT) repräsentiert

now = Time.now
# => 2022-08-18 10:24:13.5398485 -0500
now.utc? # => false
now.getutc.utc? # => true
utc = Time.utc(2000, 1, 1, 20, 15, 1)
# => 2000-01-01 20:15:01 UTC
utc.utc? # => true

Time-Objekte, die mit diesen Methoden erstellt werden, gelten als in UTC

• Time.utc

• Time#utc

• Time#getutc

Objekte, die auf andere Weise erstellt werden, werden nicht als UTC behandelt, auch wenn die Umgebungsvariable „TZ“ auf „UTC“ gesetzt ist.

Verwandt: Time.utc.

Gibt den ganzzahligen Wochentag für self zurück, im Bereich (0..6), wobei Sonntag null ist.

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.wday    # => 0
t.sunday? # => true

Verwandt: Time#year, Time#hour, Time#min.

Gibt true zurück, wenn self eine Mittwoch repräsentiert, andernfalls false

t = Time.utc(2000, 1, 5) # => 2000-01-05 00:00:00 UTC
t.wednesday?             # => true

Verwandt: Time#thursday?, Time#friday?, Time#saturday?.

Gibt eine Zeichenkette zurück, die die Zeit als dateTime darstellt, wie es durch das XML-Schema definiert ist

CCYY-MM-DDThh:mm:ssTZD
CCYY-MM-DDThh:mm:ss.sssTZD

wobei TZD Z oder [+-]hh:mm ist.

Wenn self eine UTC-Zeit ist, wird Z als TZD verwendet. Andernfalls wird [+-]hh:mm verwendet.

fraction_digits gibt die Anzahl der Ziffern an, die für Bruchteile von Sekunden verwendet werden sollen. Der Standardwert ist 0.

require 'time'

t = Time.now
t.iso8601  # => "2011-10-05T22:26:12-04:00"

Sie müssen 'time' benötigen, um diese Methode zu verwenden.

Gibt den ganzzahligen Tag des Jahres von self zurück, im Bereich (1..366).

Time.new(2000, 1, 1).yday   # => 1
Time.new(2000, 12, 31).yday # => 366

Gibt das ganzzahlige Jahr für self zurück

t = Time.new(2000, 1, 2, 3, 4, 5, 6)
# => 2000-01-02 03:04:05 +000006
t.year # => 2000

Verwandt: Time#mon, Time#hour, Time#min.

Gibt den Zeichenkettennamen der Zeitzone für self zurück

Time.utc(2000, 1, 1).zone # => "UTC"
Time.new(2000, 1, 1).zone # => "Central Standard Time"