class Time

[edit]

要約

時刻を表すクラスです。

Time.now は現在の時刻を返します。 File.mtime などが返すファイルのタイムスタンプは Time オブジェクトです。

Time オブジェクトは時刻を起算時からの経過秒数で保持しています。起算時は協定世界時(UTC、もしくはその旧称から GMT とも表記されます) の 1970年1月1日午前0時です。なお、うるう秒を勘定するかどうかはシステムによります。

Time オブジェクトが格納可能な時刻の範囲は環境によって異なっていましたが、 Ruby 1.9.2 からは OS の制限の影響を受けません。

また、Time オブジェクトは協定世界時と地方時のどちらのタイムゾーンを使用するかのフラグを内部に保持しています。タイムゾーンのフラグは Marshal データに保持されます。 


p Marshal.load(Marshal.dump(Time.now.gmtime)).zone
# => "UTC"

time ライブラリによって、Time.parse, Time.rfc2822, Time.httpdate, Time.iso8601 等が拡張されます。

Ruby 1.9.2 以降の Time クラスのデザインの詳細は https://staff.aist.go.jp/tanaka-akira/pub/sapporo-rubykaigi-02-akr-2009.pdf や「APIデザインケーススタディ」(https://gihyo.jp/book/2016/978-4-7741-7802-8) の第4章を参照してください。

localtime(3) も参照してください。

C 言語との違いに注意

C 言語の tm 構造体とは異なり、month は 1 月に対して 1 を返し、year は 1998 年に対して 1998 を返します。また、 yday は 1 から数えます。

目次

特異メソッド
インスタンスメソッド

継承しているメソッド

Comparableから継承しているメソッド

特異メソッド

at(time) -> Time[permalink][rdoc][edit]
at(time, in:) -> Time

time で指定した時刻の Time オブジェクトを返します。

キーワード引数 in でタイムゾーンを指定できます。タイムゾーンの指定がなく引数が数値の場合、生成された Time オブジェクトのタイムゾーンは地方時となります。

[PARAM] time:
Time オブジェクト、もしくは起算時からの経過秒数を表わす数値で指定します。
[PARAM] in:
"+HH:MM" や "-HH:MM" のような形式の文字列か "UTC" かミリタリータイムゾーンの文字列または数値でタイムゾーンを指定します。 

Time.at(0)                                # => 1970-01-01 09:00:00 +0900
Time.at(Time.at(0))                       # => 1970-01-01 09:00:00 +0900
Time.at(Time.at(0).getutc)                # => 1970-01-01 00:00:00 UTC
Time.at(946702800)                        # => 2000-01-01 14:00:00 +0900
Time.at(-284061600)                       # => 1960-12-31 15:00:00 +0900
Time.at(946684800.2).usec                 # => 200000
Time.at(1582721899, in: "+09:00")         # => 2020-02-26 21:58:19 +0900
Time.at(1582721899, in: 9*60*60)          # => 2020-02-26 21:58:19 +0900
Time.at(1582721899, in: "UTC")            # => 2020-02-26 12:58:19 UTC
Time.at(1582721899, in: "C")              # => 2020-02-26 13:58:19 +0300
at(time, usec) -> Time[permalink][rdoc][edit]
at(time, usec, in:) -> Time

time + (usec/1000000) の時刻を表す Time オブジェクトを返します。浮動小数点の精度では不十分な場合に使用します。

キーワード引数 in でタイムゾーンを指定できます。タイムゾーンの指定がない場合、生成された Time オブジェクトのタイムゾーンは地方時となります。

[PARAM] time:
起算時からの経過秒数を表わす値をInteger、 Float、 Rational、または他のNumericで指定します。
[PARAM] usec:
マイクロ秒をInteger、 Float、 Rational、または他のNumericで指定します。
[PARAM] in:
"+HH:MM" や "-HH:MM" のような形式の文字列か "UTC" かミリタリータイムゾーンの文字列または数値でタイムゾーンを指定します。 

Time.at(946684800, 123456.789).nsec  # => 123456789
at(seconds, xseconds, unit) -> Time[permalink][rdoc][edit]
at(seconds, xseconds, unit, in:) -> Time

unit に応じて seconds + xseconds ミリ秒などの時刻を表す Time オブジェクトを返します。

[PARAM] seconds:
起算時からの経過秒数を表わす値をInteger、 Float、 Rational、または他のNumericで指定します。
[PARAM] xseconds:
unit に対応するミリ秒かマイクロ秒かナノ秒を指定します。
[PARAM] unit:
:millisecond, :usec, :microsecond, :nsec, :nanosecond のいずれかを指定します。
[PARAM] in:
"+HH:MM" や "-HH:MM" のような形式の文字列か "UTC" かミリタリータイムゾーンの文字列または数値でタイムゾーンを指定します。 

Time.at(946684800, 123.456789, :millisecond).nsec  # => 123456789
Time.at(946684800, 123456.789, :usec).nsec         # => 123456789
Time.at(946684800, 123456.789, :microsecond).nsec  # => 123456789
Time.at(946684800, 123456789, :nsec).nsec          # => 123456789
gm(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time[permalink][rdoc][edit]
utc(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time

引数で指定した協定世界時の Time オブジェクトを返します。

第2引数以降に nil を指定した場合の値はその引数がとり得る最小の値です。

[PARAM] year:
年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。
[PARAM] mon:
1(1月)から 12(12月)の範囲の整数または文字列で指定します。英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
[PARAM] day:
日を 1 から 31 までの整数か文字列で指定します。
[PARAM] hour:
時を 0 から 23 までの整数か文字列で指定します。
[PARAM] min:
分を 0 から 59 までの整数か文字列で指定します。
[PARAM] sec:
秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
[PARAM] usec:
マイクロ秒を整数か文字列で指定します。
[EXCEPTION] ArgumentError:
与えられた引数の範囲が valid でない場合に発生します。 

p Time.gm(2000, 1, 1)  # => 2000-01-01 00:00:00 UTC
gm(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time[permalink][rdoc][edit]
utc(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time

引数で指定した協定世界時の Time オブジェクトを返します。

引数の順序は Time#to_a と全く同じです。引数 wday, yday, zone に指定した値は無視されます。引数に nil を指定した場合の値はその引数がとり得る最小の値です。

[PARAM] sec:
秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
[PARAM] min:
分を 0 から 59 までの整数か文字列で指定します。
[PARAM] hour:
時を 0 から 23 までの整数か文字列で指定します。
[PARAM] mday:
日を 1 から 31 までの整数か文字列で指定します。
[PARAM] mon:
1(1月)から 12(12月)の範囲の整数か文字列で指定します。英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
[PARAM] year:
年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。
[PARAM] wday:
無視されます。
[PARAM] yday:
無視されます。
[PARAM] isdst:
指定した日時が夏時間(Daylight Saving Time)なら true を指定します。そうでないなら、false を指定します。
[PARAM] zone:
無視されます。
[EXCEPTION] ArgumentError:
与えられた引数の範囲が valid でない場合に発生します。
local(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time[permalink][rdoc][edit]
mktime(year, mon = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0) -> Time

引数で指定した地方時の Time オブジェクトを返します。

第2引数以降に nil を指定した場合の値はその引数がとり得る最小の値です。

[PARAM] year:
年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。
[PARAM] mon:
1(1月)から 12(12月)の範囲の整数または文字列で指定します。英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
[PARAM] day:
日を 1 から 31 までの整数か文字列で指定します。
[PARAM] hour:
時を 0 から 23 までの整数か文字列で指定します。
[PARAM] min:
分を 0 から 59 までの整数か文字列で指定します。
[PARAM] sec:
秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
[PARAM] usec:
マイクロ秒を整数か文字列で指定します。
[EXCEPTION] ArgumentError:
与えられた引数の範囲が valid でない場合に発生します。 

p Time.local(2000, 1, 1) # => 2000-01-01 00:00:00 +0900
local(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time[permalink][rdoc][edit]
mktime(sec, min, hour, mday, mon, year, wday, yday, isdst, zone) -> Time

引数で指定した地方時の Time オブジェクトを返します。

引数の順序は Time#to_a と全く同じです。引数 wday, yday, zone に指定した値は無視されます。引数に nil を指定した場合の値はその引数がとり得る最小の値です。

[PARAM] sec:
秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
[PARAM] min:
分を 0 から 59 までの整数か文字列で指定します。
[PARAM] hour:
時を 0 から 23 までの整数か文字列で指定します。
[PARAM] mday:
日を 1 から 31 までの整数か文字列で指定します。
[PARAM] mon:
1(1月)から 12(12月)の範囲の整数か文字列で指定します。英語の月名("Jan", "Feb", ... などの省略名。文字の大小は無視)も指定できます。
[PARAM] year:
年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。
[PARAM] wday:
無視されます。
[PARAM] yday:
無視されます。
[PARAM] isdst:
指定した日時が夏時間(Daylight Saving Time)なら true を指定します。そうでないなら、false を指定します。
[PARAM] zone:
無視されます。
[EXCEPTION] ArgumentError:
与えられた引数の範囲が valid でない場合に発生します。
new -> Time[permalink][rdoc][edit]
now -> Time

現在時刻の Time オブジェクトを生成して返します。タイムゾーンは地方時となります。 


p Time.now # => 2009-06-24 12:39:54 +0900
new(year, mon = nil, day = nil, hour = nil, min = nil, sec = nil, zone = nil) -> Time[permalink][rdoc][edit]
new(year, mon = nil, day = nil, hour = nil, min = nil, sec = nil, in: nil) -> Time

引数で指定した地方時の Time オブジェクトを返します。

mon day hour min sec に nil を指定した場合の値は、その引数がとり得る最小の値です。 zone と in に nil を指定した場合の値は、現在のタイムゾーンに従います。

[PARAM] year:
年を整数か文字列で指定します。例えば 1998 年に対して 1998 を指定します。
[PARAM] mon:
1(1月)から 12(12月)の範囲の整数または文字列で指定します。英語の月名("Jan", "Feb", ... などの省略名。大文字小文字の違いは無視します)も指定できます。
[PARAM] day:
日を 1 から 31 までの整数か文字列で指定します。
[PARAM] hour:
時を 0 から 23 までの整数か文字列で指定します。
[PARAM] min:
分を 0 から 59 までの整数か文字列で指定します。
[PARAM] sec:
秒を 0 から 60 までの整数か文字列で指定します。(60はうるう秒)
[PARAM] zone:
協定世界時との時差を、秒を単位とする整数か、 "UTC" かミリタリータイムゾーンの文字列または "+HH:MM" "-HH:MM" 形式の文字列で指定します。
[PARAM] in:
協定世界時との時差を、秒を単位とする整数か、 "UTC" かミリタリータイムゾーンの文字列または "+HH:MM" "-HH:MM" 形式の文字列で指定します。
[EXCEPTION] ArgumentError:
与えられた引数が無効である場合に発生します。
[EXCEPTION] ArgumentError:
zone と in を同時に指定した場合に発生します。 

p Time.new(2008, 6, 21, 13, 30, 0, "+09:00") # => 2008-06-21 13:30:00 +0900
new(iso8601, in: nil) -> Time[permalink][rdoc][edit]

引数で指定した地方時の Time オブジェクトを返します。

[PARAM] iso8601:
Time#inspectの結果や制限されたISO-8601形式などの文字列を指定します。
[PARAM] in:
協定世界時との時差を、秒を単位とする整数か、 "UTC" かミリタリータイムゾーンの文字列または "+HH:MM" "-HH:MM" 形式の文字列で指定します。 iso8601 に指定された文字列がタイムゾーンを持っている場合は無視されます。
[EXCEPTION] ArgumentError:
iso8601が無効な形式の場合に発生します。 

p Time.new("2024-02-15 10:20:30")                  # => 2024-02-15 10:20:30 +0900
p Time.new("2024-02-15 10:20:30 UTC", in: "+0800") # => 2024-02-15 10:20:30 UTC
p Time.new("2024-02-15 10:20:30", in: "+0800")     # => 2024-02-15 10:20:30 +0800

インスタンスメソッド

self + other -> Time[permalink][rdoc][edit]

self より other 秒だけ後の時刻を返します。

[PARAM] other:
自身からの秒数を数値で指定します。 

p t = Time.local(2000)  # => 2000-01-01 00:00:00 +0900
p t + (60 * 60 * 24)    # => 2000-01-02 00:00:00 +0900
self - time -> Float[permalink][rdoc][edit]

自身と time との時刻の差を Float で返します。単位は秒です。

[PARAM] time:
自身との差を算出したい Time オブジェクトを指定します。 

p t = Time.local(2000)  # => 2000-01-01 00:00:00 +0900
p t2 = t + 2592000      # => 2000-01-31 00:00:00 +0900
p t2 - t                # => 2592000.0
self - sec -> Time[permalink][rdoc][edit]

自身より sec 秒だけ前の時刻を返します。

[PARAM] sec:
実数を秒を単位として指定します。 

p t = Time.local(2000)  # => 2000-01-01 00:00:00 +0900
p t2 = t + 2592000      # => 2000-01-31 00:00:00 +0900
p t2 - 2592000          # => 2000-01-01 00:00:00 +0900
self <=> other -> -1 | 0 | 1 | nil[permalink][rdoc][edit]

self と other の時刻を比較します。self の方が大きい場合は 1 を、等しい場合は 0 を、小さい場合は -1 を返します。比較できない場合は、nil を返します。

[PARAM] other:
自身と比較したい時刻を Time オブジェクトで指定します。 

p t = Time.local(2000)  # => 2000-01-01 00:00:00 +0900
p t2 = t + 2592000      # => 2000-01-31 00:00:00 +0900
p t <=> t2              # => -1
p t2 <=> t              # => 1


p t = Time.local(2000)  # => 2000-01-01 00:00:00 +0900
p t2 = t + 0.1          # => 2000-01-01 00:00:00 +0900
p t.nsec                # => 0
p t2.nsec               # => 100000000
p t <=> t2              # => -1
p t2 <=> t              # => 1
p t <=> t               # => 0
asctime -> String[permalink][rdoc][edit]
ctime -> String

時刻を asctime(3) の形式の文字列に変換します。ただし、末尾の改行文字 "\n" は含まれません。

戻り値の文字エンコーディングは Encoding::US_ASCII です。 


p Time.local(2000).asctime            # => "Sat Jan  1 00:00:00 2000"
p Time.local(2000).asctime.encoding   # => #<Encoding:US-ASCII>
p Time.local(2000).ctime              # => "Sat Jan  1 00:00:00 2000"
ceil(ndigits=0) -> Time[permalink][rdoc][edit]

十進小数点数で指定した桁数の精度で切り上げをし、その Time オブジェクトを返します。 (デフォルトは0、つまり小数点の所で切り上げます)。

ndigits には 0 以上の整数を渡します。

[PARAM] ndigits:
十進での精度(桁数) 

require 'time'

t = Time.utc(2010,3,30, 5,43,25.0123456789r)
t.iso8601(10)          # => "2010-03-30T05:43:25.0123456789Z"
t.ceil.iso8601(10)     # => "2010-03-30T05:43:26.0000000000Z"
t.ceil(0).iso8601(10)  # => "2010-03-30T05:43:26.0000000000Z"
t.ceil(1).iso8601(10)  # => "2010-03-30T05:43:25.1000000000Z"
t.ceil(2).iso8601(10)  # => "2010-03-30T05:43:25.0200000000Z"
t.ceil(3).iso8601(10)  # => "2010-03-30T05:43:25.0130000000Z"
t.ceil(4).iso8601(10)  # => "2010-03-30T05:43:25.0124000000Z"

t = Time.utc(1999,12,31, 23,59,59)
(t + 0.4).ceil.iso8601(3)    # => "2000-01-01T00:00:00.000Z"
(t + 0.9).ceil.iso8601(3)    # => "2000-01-01T00:00:00.000Z"
(t + 1.4).ceil.iso8601(3)    # => "2000-01-01T00:00:01.000Z"
(t + 1.9).ceil.iso8601(3)    # => "2000-01-01T00:00:01.000Z"

t = Time.utc(1999,12,31, 23,59,59)
(t + 0.123456789).ceil(4).iso8601(6)  # => "1999-12-31T23:59:59.123500Z"

[SEE_ALSO] Time#floor, Time#round

mday -> Integer[permalink][rdoc][edit]
day -> Integer

日を整数で返します。 


t = Time.local(2000,1,2,3,4,5)  # => 2000-01-02 03:04:05 +0900
p t.day                         # => 2
p t.mday                        # => 2
deconstruct_keys(array_of_names_or_nil) -> Hash[permalink][rdoc][edit]

パターンマッチに使用する名前と値の Hash を返します。

キーに利用できる名前は以下の通りです。

  • :year
  • :month
  • :day
  • :yday
  • :wday
  • :hour
  • :min
  • :sec
  • :subsec
  • :dst
  • :zone
[PARAM] array_of_names_or_nil:
パターンマッチに使用する名前の配列を指定します。nil の場合は全てをパターンマッチに使用します。 
例

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

if t in wday: 3, day: ..7 # deconstruct_keys が使われます
  puts "first Wednesday of the month"
end
#=> "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
#=> "working day in month 10" が出力される

# クラスのチェックと組み合わせて利用することもできます
if t in Time(wday: 3, day: ..7)
  puts "first Wednesday of the month"
end

[SEE_ALSO] パターンマッチ/非プリミティブなオブジェクトのマッチ: deconstruct メソッドと deconstruct_keys メソッド

isdst -> bool[permalink][rdoc][edit]
dst? -> bool

自身が表す日時が夏時間なら true を返します。そうでないなら false を返します。 


ENV['TZ'] = 'US/Pacific'
p Time.local(2000, 7, 1).isdst   # => true
p Time.local(2000, 1, 1).isdst   # => false
eql?(other) -> bool[permalink][rdoc][edit]

other が Time かそのサブクラスのインスタンスであり自身と時刻が等しい場合に true を返します。そうでない場合に false を返します。

[PARAM] other:
自身と比較したい時刻を Time オブジェクトを指定します。 

p Time.local(2000, 1, 1).eql?(Time.local(2000, 1, 1))   # => true
p Time.local(2000, 1, 1).eql?(Time.local(2000, 1, 2))   # => false
floor(ndigits=0) -> Time[permalink][rdoc][edit]

十進小数点数で指定した桁数の精度で切り捨てをし、その Time オブジェクトを返します。 (デフォルトは0、つまり小数点の所で切り捨てます)。

ndigits には 0 以上の整数を渡します。

[PARAM] ndigits:
十進での精度(桁数) 

require 'time'

t = Time.utc(2010,3,30, 5,43,25.123456789r)
t.iso8601(10)           # => "2010-03-30T05:43:25.1234567890Z"
t.floor.iso8601(10)     # => "2010-03-30T05:43:25.0000000000Z"
t.floor(0).iso8601(10)  # => "2010-03-30T05:43:25.0000000000Z"
t.floor(1).iso8601(10)  # => "2010-03-30T05:43:25.1000000000Z"
t.floor(2).iso8601(10)  # => "2010-03-30T05:43:25.1200000000Z"
t.floor(3).iso8601(10)  # => "2010-03-30T05:43:25.1230000000Z"
t.floor(4).iso8601(10)  # => "2010-03-30T05:43:25.1234000000Z"

t = Time.utc(1999,12,31, 23,59,59)
(t + 0.4).floor.iso8601(3)    # => "1999-12-31T23:59:59.000Z"
(t + 0.9).floor.iso8601(3)    # => "1999-12-31T23:59:59.000Z"
(t + 1.4).floor.iso8601(3)    # => "2000-01-01T00:00:00.000Z"
(t + 1.9).floor.iso8601(3)    # => "2000-01-01T00:00:00.000Z"

t = Time.utc(1999,12,31, 23,59,59)
(t + 0.123456789).floor(4).iso8601(6)  # => "1999-12-31T23:59:59.123400Z"

[SEE_ALSO] Time#ceil, Time#round

friday? -> bool[permalink][rdoc][edit]

self の表す時刻が金曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(1987, 12, 18)     # => 1987-12-18 00:00:00 +0900
p t.friday?                      # => true
getgm -> Time[permalink][rdoc][edit]
getutc -> Time

タイムゾーンを協定世界時に設定した Time オブジェクトを新しく生成して返します。 


p t = Time.local(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 +0900
p t.gmt?                             #=> false
p y = t.getgm                        #=> 2000-01-01 11:15:01 UTC
p y.gmt?                             #=> true
p t == y                             #=> true
getlocal -> Time[permalink][rdoc][edit]
getlocal(utc_offset) -> Time

タイムゾーンを地方時に設定した Time オブジェクトを新しく生成して返します。

[PARAM] utc_offset:
タイムゾーンを地方時に設定する代わりに協定世界時との時差を、秒を単位とする整数か、"+HH:MM" "-HH:MM" 形式の文字列で指定します。 

p t = Time.utc(2000,1,1,20,15,1)  # => 2000-01-01 20:15:01 UTC
p t.utc?                          # => true
p l = t.getlocal                  # => 2000-01-02 05:15:01 +0900
p l.utc?                          # => false
p t == l                          # => true
p j = t.getlocal("+09:00")        # => 2000-01-02 05:15:01 +0900
p j.utc?                          # => false
p t == j                          # => true
gmt? -> bool[permalink][rdoc][edit]
utc? -> bool

self のタイムゾーンが協定世界時に設定されていれば真を返します。 


p t = Time.local(2017,9,19,15,0,0)   # => 2017-09-19 15:00:00 +0900
p t.utc?                             # => false
p utc_t = t.getutc                   # => 2017-09-19 06:00:00 UTC
p utc_t.utc?                         # => true
utc_offset -> Integer[permalink][rdoc][edit]
gmt_offset -> Integer
gmtoff -> Integer

協定世界時との時差を秒を単位とする数値として返します。

地方時が協定世界時よりも進んでいる場合(アジア、オーストラリアなど) には正の値、遅れている場合(アメリカなど)には負の値になります。 

地方時の場合

p Time.now.zone        # => "JST"
p Time.now.utc_offset  # => 32400

タイムゾーンが協定世界時に設定されている場合は 0 を返します。 

協定世界時の場合

p Time.now.getgm.zone        # => "UTC"
p Time.now.getgm.utc_offset  # => 0
gmtime -> self[permalink][rdoc][edit]
utc -> self

タイムゾーンを協定世界時に設定します。

このメソッドを呼び出した後は時刻変換を協定世界時として行ないます。

Time#localtime, Time#gmtime の挙動はシステムの localtime(3) の挙動に依存します。Time クラスでは時刻を起算時からの経過秒数として保持していますが、ある特定の時刻までの経過秒は、システムがうるう秒を勘定するかどうかによって異なる場合があります。システムを越えて Time オブジェクトを受け渡す場合には注意する必要があります。 


p t = Time.local(2000,1,1,20,15,1)   # => 2000-01-01 20:15:01 +0900
p t.gmt?                             # => false
p t.gmtime                           # => 2000-01-01 11:15:01 UTC
p t.gmt?                             # => true
hash -> Integer[permalink][rdoc][edit]

self のハッシュ値を返します。

[RETURN]
ハッシュ値を返します。

[SEE_ALSO] Object#hash

hour -> Integer[permalink][rdoc][edit]

時を整数で返します。 


t = Time.local(2000,1,2,3,4,5)  # => 2000-01-02 03:04:05 +0900
p t.hour                        # => 3
inspect -> String[permalink][rdoc][edit]

時刻を文字列に変換した結果を返します。

Time#to_s とは異なりナノ秒まで含めて返します。 


t = Time.now
t.inspect                             #=> "2012-11-10 18:16:12.261257655 +0100"
t.strftime "%Y-%m-%d %H:%M:%S.%N %z"  #=> "2012-11-10 18:16:12.261257655 +0100"

t.utc.inspect                          #=> "2012-11-10 17:16:12.261257655 UTC"
t.strftime "%Y-%m-%d %H:%M:%S.%N UTC"  #=> "2012-11-10 17:16:12.261257655 UTC"

戻り値の文字エンコーディングは Encoding::US_ASCII です。

localtime -> self[permalink][rdoc][edit]
localtime(utc_offset) -> self

タイムゾーンを地方時に設定します。

このメソッドを呼び出した後は時刻変換を協定地方時として行ないます。

[PARAM] utc_offset:
タイムゾーンを地方時に設定する代わりに協定世界時との時差を、秒を単位とする整数か、"+HH:MM" "-HH:MM" 形式の文字列で指定します。

Time#localtime, Time#gmtime の挙動はシステムの localtime(3) の挙動に依存します。Time クラスでは時刻を起算時からの経過秒数として保持していますが、ある特定の時刻までの経過秒は、システムがうるう秒を勘定するかどうかによって異なる場合があります。システムを越えて Time オブジェクトを受け渡す場合には注意する必要があります。 


p t = Time.utc(2000, "jan", 1, 20, 15, 1)  # => 2000-01-01 20:15:01 UTC
p t.utc?                                   # => true
p t.localtime                              # => 2000-01-02 05:15:01 +0900
p t.utc?                                   # => false

p t.localtime("+09:00")                    # => 2000-01-02 05:15:01 +0900
p t.utc?                                   # => false
min -> Integer[permalink][rdoc][edit]

分を整数で返します。 


t = Time.local(2000,1,2,3,4,5)  # => 2000-01-02 03:04:05 +0900
p t.min                         # => 4
mon -> Integer[permalink][rdoc][edit]
month -> Integer

月を整数で返します。 


t = Time.local(2000,1,2,3,4,5)  # => 2000-01-02 03:04:05 +0900
p t.month                       # => 1
p t.mon                         # => 1
monday? -> bool[permalink][rdoc][edit]

self の表す時刻が月曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(2003, 8, 4)       # => 2003-08-04 00:00:00 +0900
p t.monday?                      # => true
nsec -> Integer[permalink][rdoc][edit]
tv_nsec -> Integer

時刻のナノ秒の部分を整数で返します。 


t = Time.local(2000,1,2,3,4,5,6)
p "%10.9f" % t.to_f   # => "946749845.000005960"
p t.nsec              # => 6000

IEEE 754 浮動小数点数で表現できる精度が違うため、Time#to_fの最小の桁とnsecの最小の桁は異なります。nsecで表される値の方が正確です。

round(ndigits=0) -> Time[permalink][rdoc][edit]

十進小数点数で指定した桁数の精度で丸めをし、その Time オブジェクトを返します。 (デフォルトは0、つまり小数点の所で丸めます)。

ndigits には 0 以上の整数を渡します。

[PARAM] ndigits:
十進での精度(桁数) 

require 'time'

t = Time.utc(1999,12,31, 23,59,59)
p((t + 0.4).round.iso8601(3))    # => "1999-12-31T23:59:59.000Z"
p((t + 0.49).round.iso8601(3))   # => "1999-12-31T23:59:59.000Z"
p((t + 0.5).round.iso8601(3))    # => "2000-01-01T00:00:00.000Z"
p((t + 1.4).round.iso8601(3))    # => "2000-01-01T00:00:00.000Z"
p((t + 1.49).round.iso8601(3))   # => "2000-01-01T00:00:00.000Z"
p((t + 1.5).round.iso8601(3))    # => "2000-01-01T00:00:01.000Z"

t = Time.utc(1999,12,31, 23,59,59)
p (t + 0.123456789).round(4).iso8601(6)  # => "1999-12-31T23:59:59.123500Z"

[SEE_ALSO] Time#ceil, Time#floor

saturday? -> bool[permalink][rdoc][edit]

self の表す時刻が土曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(2006, 6, 10)      # => 2006-06-10 00:00:00 +0900
p t.saturday?                    # => true
sec -> Integer[permalink][rdoc][edit]

秒を整数で返します。 


p Time.mktime(2000, 1, 1).sec # => 0

通常は0から59を返しますが、うるう秒の場合は60を返します。 


ENV['TZ'] = 'right/UTC'
p Time.mktime(2005, 12, 31, 23, 59, 60).sec # => 60
strftime(format) -> String[permalink][rdoc][edit]

時刻を format 文字列に従って文字列に変換した結果を返します。

[PARAM] format:
フォーマット文字列を指定します。使用できるものは 以下の通りです。
  • %A: 曜日の名称(Sunday, Monday ... )
  • %a: 曜日の省略名(Sun, Mon ... )
  • %B: 月の名称(January, February ... )
  • %b: 月の省略名(Jan, Feb ... )
  • %C: 世紀 (2009年であれば 20)
  • %c: 日付と時刻 (%a %b %e %T %Y)
  • %D: 日付 (%m/%d/%y)
  • %d: 日(01-31)
  • %e: 日。一桁の場合、半角空白で埋める ( 1..31)
  • %F: %Y-%m-%d と同等 (ISO 8601の日付フォーマット)
  • %G: ISO 8601の暦週の年
  • %g: ISO 8601の暦週の年の下2桁(00-99)
  • %H: 24時間制の時(00-23)
  • %h: %b と同等
  • %I: 12時間制の時(01-12)
  • %j: 年中の通算日(001-366)
  • %k: 24時間制の時。一桁の場合、半角空白で埋める ( 0..23)
  • %L: ミリ秒 (000..999)
  • %l: 12時間制の時。一桁の場合、半角空白で埋める ( 0..12)
  • %M: 分(00-59)
  • %m: 月を表す数字(01-12)
  • %n: 改行 (\n)
  • %N: 秒の小数点以下。桁の指定がない場合は9桁 (ナノ秒)、%6N: マイクロ秒 (6桁)、%3N: ミリ秒 (3桁)
  • %P: 午前または午後(am,pm)
  • %p: 午前または午後(AM,PM)
  • %Q: 1970-01-01 00:00:00 UTC からの経過ミリ秒 (Time#strftime は対応していませんが、Date#strftime で使えます)
  • %R: 24時間制の時刻。%H:%M と同等。
  • %r: 12時間制の時刻。%I:%M:%S %p と同等。
  • %S: 秒(00-60) (60はうるう秒)
  • %s: 1970-01-01 00:00:00 UTC からの経過秒
  • %T: 24時間制の時刻。%H:%M:%S と同等。
  • %t: タブ文字 (\t)
  • %U: 週を表す数。最初の日曜日が第1週の始まり(00-53)
  • %u: 月曜日を1とした、曜日の数値表現 (1..7)
  • %V: ISO 8601形式の暦週 (01..53)
  • %v: VMS形式の日付 (%e-%^b-%4Y)
  • %W: 週を表す数。最初の月曜日が第1週の始まり(00-53)
  • %w: 曜日を表す数。日曜日が0(0-6)
  • %X: 時刻 (%Tと同等)
  • %x: 日付 (%Dと同等)
  • %Y: 西暦を表す数
  • %y: 西暦の下2桁(00-99)
  • %Z: タイムゾーン (環境依存)
  • %z: タイムゾーン。UTCからのオフセット (例 +0900)
  • %:z: タイムゾーン。コロンが入ったUTCからのオフセット (例 +09:00)
  • %::z: タイムゾーン。コロンが入った秒まで含むUTCからのオフセット (例 +09:00:00)
  • %%: %自身
  • %+: date(1)の形式 (%a %b %e %H:%M:%S %Z %Y) (Time#strftime は対応していませんが、Date#strftime で使えます)

このメソッドは strftime(3) や glibcの仕様を参考に作成されており、以下のオプションが利用できます。

  • ^: 大文字で出力を行なう
  • #: 小文字であれば大文字に、大文字であれば小文字に変更する
  • -: 左寄せにする(0埋めや空白埋めを行わない)
  • _: 空白埋めにする
  • 0: 0埋めにする
  • 数値: 表示桁数を指定する

EとOは無視されます。 

例

p t = Time.new(2001,2,3,4,5,6,"+09:00")  # => 2001-02-03 04:05:06 +0900
p t.strftime("Printed on %m/%d/%Y")      # => "Printed on 02/03/2001"
p t.strftime("Printed on %m/%-d/%_6Y")   # => "Printed on 02/3/  2001"
p t.strftime("at %I:%M%p")               # => "at 04:05AM"
p t.strftime("at %I:%M%#p")              # => "at 04:05am"

様々なISO 8601形式

t = Time.new(2001,2,3,4,5,6,"+09:00")
p t.strftime("%Y%m%d")           # => 20010203                  Calendar date (basic)
p t.strftime("%F")               # => 2001-02-03                Calendar date (extended)
p t.strftime("%Y-%m")            # => 2001-02                   Calendar date, reduced accuracy, specific month
p t.strftime("%Y")               # => 2001                      Calendar date, reduced accuracy, specific year
p t.strftime("%C")               # => 20                        Calendar date, reduced accuracy, specific century
p t.strftime("%Y%j")             # => 2001034                   Ordinal date (basic)
p t.strftime("%Y-%j")            # => 2001-034                  Ordinal date (extended)
p t.strftime("%GW%V%u")          # => 2001W056                  Week date (basic)
p t.strftime("%G-W%V-%u")        # => 2001-W05-6                Week date (extended)
p t.strftime("%GW%V")            # => 2001W05                   Week date, reduced accuracy, specific week (basic)
p t.strftime("%G-W%V")           # => 2001-W05                  Week date, reduced accuracy, specific week (extended)
p t.strftime("%H%M%S")           # => 040506                    Local time (basic)
p t.strftime("%T")               # => 04:05:06                  Local time (extended)
p t.strftime("%H%M")             # => 0405                      Local time, reduced accuracy, specific minute (basic)
p t.strftime("%H:%M")            # => 04:05                     Local time, reduced accuracy, specific minute (extended)
p t.strftime("%H")               # => 04                        Local time, reduced accuracy, specific hour
p t.strftime("%H%M%S,%L")        # => 040506,000                Local time with decimal fraction, comma as decimal sign (basic)
p t.strftime("%T,%L")            # => 04:05:06,000              Local time with decimal fraction, comma as decimal sign (extended)
p t.strftime("%H%M%S.%L")        # => 040506.000                Local time with decimal fraction, full stop as decimal sign (basic)
p t.strftime("%T.%L")            # => 04:05:06.000              Local time with decimal fraction, full stop as decimal sign (extended)
p t.strftime("%H%M%S%z")         # => 040506+0900               Local time and the difference from UTC (basic)
p t.strftime("%T%:z")            # => 04:05:06+09:00            Local time and the difference from UTC (extended)
p t.strftime("%Y%m%dT%H%M%S%z")  # => 20010203T040506+0900      Date and time of day for calendar date (basic)
p t.strftime("%FT%T%:z")         # => 2001-02-03T04:05:06+09:00 Date and time of day for calendar date (extended)
p t.strftime("%Y%jT%H%M%S%z")    # => 2001034T040506+0900       Date and time of day for ordinal date (basic)
p t.strftime("%Y-%jT%T%:z")      # => 2001-034T04:05:06+09:00   Date and time of day for ordinal date (extended)
p t.strftime("%GW%V%uT%H%M%S%z") # => 2001W056T040506+0900      Date and time of day for week date (basic)
p t.strftime("%G-W%V-%uT%T%:z")  # => 2001-W05-6T04:05:06+09:00 Date and time of day for week date (extended)
p t.strftime("%Y%m%dT%H%M")      # => 20010203T0405             Calendar date and local time (basic)
p t.strftime("%FT%R")            # => 2001-02-03T04:05          Calendar date and local time (extended)
p t.strftime("%Y%jT%H%MZ")       # => 2001034T0405Z             Ordinal date and UTC of day (basic)
p t.strftime("%Y-%jT%RZ")        # => 2001-034T04:05Z           Ordinal date and UTC of day (extended)
p t.strftime("%GW%V%uT%H%M%z")   # => 2001W056T0405+0900        Week date and local time and difference from UTC (basic)
p t.strftime("%G-W%V-%uT%R%:z")  # => 2001-W05-6T04:05+09:00    Week date and local time and difference from UTC (extended)
subsec -> Integer | Rational[permalink][rdoc][edit]

時刻を表す分数を返します。

Rational を返す場合があります。 


t = Time.local(2000,1,2,3,4,5,6)
p "%10.9f" % t.to_f   # => "946749845.000005960"
p t.subsec            #=> (3/500000)

to_f の値と subsec の値の下のほうの桁の値は異なる場合があります。というのは IEEE 754 double はそれを表すのに十分な精度を持たないからです。subsec で得られる値が正確です。

sunday? -> bool[permalink][rdoc][edit]

self の表す時刻が日曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(1990, 4, 1)       # => 1990-04-01 00:00:00 +0900
p t.sunday?                      # => true
thursday? -> bool[permalink][rdoc][edit]

self の表す時刻が木曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(1995, 12, 21)     # => 1995-12-21 00:00:00 +0900
p t.thursday?                    # => true
to_a -> Array[permalink][rdoc][edit]

時刻を10要素の配列で返します。

その要素は順序も含めて以下の通りです。

  • sec: 秒 (整数 0-60) (60はうるう秒)
  • min: 分 (整数 0-59)
  • hour: 時 (整数 0-23)
  • mday: 日 (整数)
  • mon: 月 (整数 1-12)
  • year: 年 (整数 2000年=2000)
  • wday: 曜日 (整数 0-6)
  • yday: 年内通算日 (整数 1-366)
  • isdst: 夏時間であるかどうか (true/false)
  • zone: タイムゾーン (文字列)

t = Time.local(2000,1,2,3,4,5)
p t       # => 2000-01-02 03:04:05 +0900
p t.to_a  # => [5, 4, 3, 2, 1, 2000, 0, 2, false, "JST"]

要素の順序は C 言語の tm 構造体に合わせています。ただし、 tm 構造体に zone はありません。

注意: C 言語の tm 構造体とは異なり、month は 1 月に対して 1 を返し、year は 1998 年に対して 1998 を返します。また、 yday は 1 から数えます。

to_f -> Float[permalink][rdoc][edit]

起算時からの経過秒数を浮動小数点数で返します。1 秒に満たない経過も表現されます。 


t = Time.local(2000,1,2,3,4,5,6)
p t                  # => 2000-01-02 03:04:05 +0900
p "%10.6f" % t.to_f  # => "946749845.000006"
p t.to_i             # => 946749845
to_i -> Integer[permalink][rdoc][edit]
tv_sec -> Integer

起算時からの経過秒数を整数で返します。 


t = Time.local(2000,1,2,3,4,5,6)
p t                  # => 2000-01-02 03:04:05 +0900
p "%10.6f" % t.to_f  # => "946749845.000006"
p t.to_i             # => 946749845
p t.tv_sec           # => 946749845
to_r -> Rational[permalink][rdoc][edit]

起算時からの経過秒数を有理数で返します。1 秒に満たない経過も表現されます。 


t = Time.local(2000,1,2,3,4,5,6)
p t          # => 2000-01-02 03:04:05 +0900
p t.to_r     # => (473374922500003/500000)
to_s -> String[permalink][rdoc][edit]

時刻を文字列に変換した結果を返します。以下のようにフォーマット文字列を使って strftime を呼び出すのと同じです。 


t = Time.local(2000,1,2,3,4,5,6)
p t.to_s                               # => "2000-01-02 03:04:05 +0900"
p t.strftime("%Y-%m-%d %H:%M:%S %z")   # => "2000-01-02 03:04:05 +0900"

p t.utc.to_s                           # => "2000-01-01 18:04:05 UTC"
p t.strftime("%Y-%m-%d %H:%M:%S UTC")  # => "2000-01-01 18:04:05 UTC"

戻り値の文字エンコーディングは Encoding::US_ASCII です。

tuesday? -> bool[permalink][rdoc][edit]

self の表す時刻が火曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(1991, 2, 19)      # => 1991-02-19 00:00:00 +0900
p t.tuesday?                     # => true
usec -> Integer[permalink][rdoc][edit]
tv_usec -> Integer

時刻のマイクロ秒の部分を整数で返します。 


t = Time.local(2000,1,2,3,4,5,6)
p "%10.6f" % t.to_f   #=> "946749845.000006"
p t.usec              #=> 6
wday -> Integer[permalink][rdoc][edit]

曜日を0(日曜日)から6(土曜日)の整数で返します。 


p sun = Time.new(2017, 9, 17, 10, 34, 15, '+09:00') # => 2017-09-17 10:34:15 +0900
p sun.wday                                          # => 0
p mon = Time.new(2017, 9, 18, 10, 34, 15, '+09:00') # => 2017-09-18 10:34:15 +0900
p mon.wday                                          # => 1
p tue = Time.new(2017, 9, 19, 10, 34, 15, '+09:00') # => 2017-09-19 10:34:15 +0900
p tue.wday                                          # => 2
p wed = Time.new(2017, 9, 20, 10, 34, 15, '+09:00') # => 2017-09-20 10:34:15 +0900
p wed.wday                                          # => 3
p thu = Time.new(2017, 9, 21, 10, 34, 15, '+09:00') # => 2017-09-21 10:34:15 +0900
p thu.wday                                          # => 4
p fri = Time.new(2017, 9, 22, 10, 34, 15, '+09:00') # => 2017-09-22 10:34:15 +0900
p fri.wday                                          # => 5
p sat = Time.new(2017, 9, 23, 10, 34, 15, '+09:00') # => 2017-09-23 10:34:15 +0900
p sat.wday                                          # => 6
wednesday? -> bool[permalink][rdoc][edit]

self の表す時刻が水曜日である場合に true を返します。そうでない場合に false を返します。 


t = Time.local(1993, 2, 24)      # => 1993-02-24 00:00:00 +0900
p t.wednesday?                   # => true
yday -> Integer[permalink][rdoc][edit]

1月1日を1とした通算日(1から366まで)を整数で返します。 


p Time.mktime(2000,  1,  1).yday # => 1

うるう年の場合は、2月29日も含めた通算日を返します。 

うるう年でない場合

p Time.mktime(2003,  1,  1).yday # => 1
p Time.mktime(2003,  3,  1).yday # => 60
p Time.mktime(2003, 12, 31).yday # => 365

うるう年の場合

p Time.mktime(2004,  1,  1).yday # => 1
p Time.mktime(2004,  2, 29).yday # => 60
p Time.mktime(2004, 12, 31).yday # => 366
year -> Integer[permalink][rdoc][edit]

年を整数で返します。 


t = Time.local(2000,1,2,3,4,5)  # => 2000-01-02 03:04:05 +0900
p t.year                        # => 2000
zone -> String[permalink][rdoc][edit]

タイムゾーンを表す文字列を返します。 


p Time.now.zone # => "JST"