Time

Time (시간·날짜)

Time 객체는 날짜와 시간을 나타내요.

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

그 값은 하나의 숫자로도 표현되지만(아래 [에포크 초]), 필요에 따라 부품별로 다루기도 편해요.

t = Time.new(-2000, 1, 1, 0, 0, 0.0)
# => -2000-01-01 00:00:00 -0600
t.year # => -2000
t.month # => 1
t.mday # => 1
t.hour # => 0
t.min # => 0
t.sec # => 0
t.subsec # => 0

t = Time.new(2000, 12, 31, 23, 59, 59.5)
# => 2000-12-31 23:59:59.5 -0600
t.year # => 2000
t.month # => 12
t.mday # => 31
t.hour # => 23
t.min # => 59
t.sec # => 59
t.subsec # => (1/2)

출처: Ruby 4.0 API

본문

에포크 초 (Epoch Seconds)

*에포크 초(epoch seconds)*는 Unix Epoch인 1970년 1월 1일 이후의 정확한 초 수(분수 초 포함)예요. 그 값을 정확히 얻으려면 Time#to_r을 쓰면 돼요.

Time.at(0).to_r        # => (0/1)
Time.at(0.999999).to_r # => (9007190247541737/9007199254740992)

Time#to_i나 Time#to_f 같은 다른 인출 메서드는 서브초를 반올림하거나 잘라낸 값을 돌려줄 수 있어요.

시간 해상도 (Time Resolution)

시스템 클록에서 얻은 Time 객체(예: Time.now)는 시스템이 지원하는 해상도를 가져요.

시간 내부 표현 (Time Internal Representation)

개념적으로 Time 클래스는 Epoch(1970-01-01 00:00:00 UTC)로부터의 초 수를 **유리수(rational value)**로 나타내요. 경계나 해상도 제한이 없어요. 그 값은 Time#to_r로 얻을 수 있어요.

Time 클래스는 항상 **그레고리력(proleptic Gregorian calendar)**을 사용해요. 율리우스력 같은 다른 달력은 지원하지 않아요.

구현은 부호 있는 63비트 정수, Integer(Bignum) 객체, 또는 Rational 객체로 유리수 값을 표현해요. (부호 있는 63비트 정수는 32/64비트 환경과 무관하게 사용돼요.) 그 값은 Epoch로부터의 나노초 수를 나타내요. 63비트 정수로는 1823-11-12부터 2116-02-20까지 표현할 수 있어요. Integer나 Rational 객체를 쓸 때(1823년 이전, 2116년 이후, 나노초 미만)는 63비트 정수를 쓸 때보다 Time이 느리게 동작해요.

Ruby는 숫자와 6-튜플(연, 월, 일, 시, 분, 초) 사이의 변환에 C 함수 localtime과 gmtime을 사용해요. localtime은 로컬 시간, gmtime은 UTC에 쓰여요.

Integer와 Rational은 범위 제한이 없지만, localtime과 gmtime은 C 타입 time_t와 struct tm 때문에 범위 제한이 있어요. 그 제한을 넘으면 Ruby가 localtime 함수를 외삽(extrapolate)해요.

time_t는 32비트 부호 정수면 1901-12-14부터 2038-01-19까지, 64비트 부호 정수면 -292277022657-01-27부터 292277026596-12-05까지 표현할 수 있어요. 다만 일부 플랫폼의 localtime은 음수 time_t(1970년 이전)를 지원하지 않아요.

struct tm은 연도를 나타내는 tm_year 멤버를 가져요(tm_year = 0은 1900년). C 표준에서 int로 정의돼요. int가 32비트면 tm_year는 -2147481748부터 2147485547까지의 연도를 표현할 수 있어요.

Ruby는 C 함수 localtime과 gmtime이 지원하는 한 윤초(leap second)를 지원해요. 대부분의 Unix 시스템에서 tz database를 사용하는데, tz database에는 윤초를 지원하는 타임존이 있어요. 예를 들어 "Asia/Tokyo"는 윤초를 지원하지 않지만 "right/Asia/Tokyo"는 지원해요. 그래서 대부분의 Unix 시스템에서 TZ 환경 변수를 "right/Asia/Tokyo"로 설정하면 Ruby가 윤초를 지원해요.

예시 (Examples)

이 예시들은 모두 GMT-5인 EST 타임존에서 실행된 결과예요.

새 `Time` 인스턴스 만들기

Time.new로 새 Time 인스턴스를 만들 수 있어요. 이러면 현재 시스템 시간을 사용해요. Time.now는 이 별칭이에요. Time.new에 연, 월, 분 같은 시간의 부품을 넘길 수도 있어요. 이렇게 시간을 구성하려면 최소한 연도는 넘겨야 해요. 연도만 넘기고 다른 건 넘기지 않으면 그 해 1월 1일 00:00:00, 현재 시스템 타임존이 기본값이 돼요.

Time.new(2002)         #=> 2002-01-01 00:00:00 -0500
Time.new(2002, 10)     #=> 2002-10-01 00:00:00 -0500
Time.new(2002, 10, 31) #=> 2002-10-31 00:00:00 -0500

UTC 오프셋도 넘길 수 있어요.

Time.new(2002, 10, 31, 2, 2, 2, "+02:00") #=> 2002-10-31 02:02:02 +0200

또는 [타임존 객체]를 넘길 수 있어요.

zone = timezone("Europe/Athens")      # Eastern European Time, UTC+2
Time.new(2002, 10, 31, 2, 2, 2, zone) #=> 2002-10-31 02:02:02 +0200

Time.local과 Time.utc로 현재 시스템 설정 대신 로컬/UTC 타임존을 직접 지정할 수도 있어요.

Time.at으로도 새 시간을 만들 수 있는데, 이건 Unix Epoch 이후의 초 수(서브초 포함)를 받아요.

Time.at(628232400) #=> 1989-11-28 00:00:00 -0500

`Time` 인스턴스 다루기

Time 인스턴스를 얻으면 할 수 있는 게 아주 많아요. 다음 예시들은 전부 아래처럼 시간을 만들었다고 가정해요.

t = Time.new(1993, 02, 24, 12, 0, 0, "+09:00")

월요일이었나요?

t.monday? #=> false

그때 연도는 뭐였죠?

t.year #=> 1993

그때 서머타임이었나요?

t.dst? #=> false

1년 뒤의 그날은 언제죠?

t + (60*60*24*365) #=> 1994-02-24 12:00:00 +0900

Unix Epoch 이후 몇 초가 지난 것이었죠?

t.to_i #=> 730522800

두 시간을 비교하는 일반 함수도 쓸 수 있어요.

t1 = Time.new(2010)
t2 = Time.new(2011)

t1 == t2 #=> false
t1 == t1 #=> true
t1 <  t2 #=> true
t1 >  t2 #=> false

Time.new(2010,10,31).between?(t1, t2) #=> true

뭐가 여기 있나 (What's Here)

먼저, Time 클래스의 바깥을 보면: class Object에서 상속받고, module Comparable을 포함해요.

여기 Time 클래스는 아래 용도의 메서드를 제공해요.

[만들기(Methods for Creating)]
[값 가져오기(Methods for Fetching)]
[질의하기(Methods for Querying)]
[비교하기(Methods for Comparing)]
[변환하기(Methods for Converting)]
[반올림하기(Methods for Rounding)]

만들기 (Methods for Creating)

::new - 지정한 인자(연, 월 등)와 선택 타임존 값으로 새 time을 돌려줘요.
::local (::mktime 별칭) - ::new과 같되 타임존이 로컬 타임존이에요.
::utc (::gm 별칭) - ::new과 같되 타임존이 UTC예요.
::at - 에포크 이후 초를 기준으로 새 time을 돌려줘요.
::now - 현재 시스템 시간으로 새 time을 돌려줘요.
+ (plus) - 주어진 초만큼 늘어난 새 time을 돌려줘요.
- (minus) - 주어진 초만큼 줄어든 새 time을 돌려줘요.

값 가져오기 (Methods for Fetching)

year - time의 연도. month(mon 별칭) - 월. mday(day 별칭) - 일.
hour - 시. min - 분. sec - 초.
usec(tv_usec 별칭) - 서브초 값의 마이크로초 수. nsec(tv_nsec 별칭) - 서브초의 나노초 수. subsec - 정확한 서브초.
wday - 정수 요일 값(0 == 일요일). yday - 정수 연중 일수(1 == 1월 1일).
hash - 정수 해시 값.
utc_offset(gmt_offset, gmtoff 별칭) - time과 UTC 사이의 오프셋(초).
to_f - 에포크 이후 초의 float 값. to_i(tv_sec 별칭) - 정수 값. to_r - Rational 값.
zone - time의 타임존 문자열 표현.

질의하기 (Methods for Querying)

utc?(gmt? 별칭) - UTC인지. dst?(isdst 별칭) - DST(일광 절약 시간)인지.
sunday? ~ saturday? - 각 요일인지.

비교하기 (Methods for Comparing)

<=> - self를 다른 time과 비교. eql? - 다른 time과 완전히 같은지.

변환하기 (Methods for Converting)

asctime(ctime 별칭) - 문자열로. inspect - 자세히 문자열로. strftime - 주어진 형식에 따라 문자열로. to_a - 10개 요소 배열로. to_s - 문자열 표현으로.
getutc(getgm 별칭) - UTC로 변환된 새 time. getlocal - 로컬 시간으로 변환된 새 time.
utc(gmtime 별칭) - 제자리(in place)에서 UTC로 변환. localtime - 제자리에서 로컬 시간으로 변환.
deconstruct_keys - 패턴 매칭에 쓰이는 부품 해시.

반올림하기 (Methods for Rounding)

round - 서브초를 반올림한 새 time. ceil - 올림한 새 time. floor - 내림한 새 time.

인자 zone의 형태는 [타임존 지정자(Timezone Specifiers)]를 참고하세요.

타임존 지정자 (Timezone Specifiers)

일부 Time 메서드는 타임존을 지정하는 인자를 받아요.

Time.at - 키워드 인자 in:.
Time.new - 위치 인자 zone 또는 키워드 인자 in:.
Time.now - 키워드 인자 in:.
Time#getlocal - 위치 인자 zone.
Time#localtime - 위치 인자 zone.

이 중 어디에 주는 값은 다음 중 하나여야 해요(각각 아래에서 자세히).

[시/분 오프셋(Hours/Minutes Offsets)]
[단일 문자 오프셋(Single-Letter Offsets)]
[정수 오프셋(Integer Offsets)]
[타임존 객체(Timezone Objects)]
[타임존 이름(Timezone Names)]

Hours/Minutes Offsets

zone 값은 '+HH:MM' 또는 '-HH:MM' 형태의 UTC 문자열 오프셋일 수 있어요. HH는 0..23 범위의 2자리 시, MM은 0..59 범위의 2자리 분이에요.

t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
Time.at(t, in: '-23:59')            # => 1999-12-31 20:16:01 -2359
Time.at(t, in: '+23:59')            # => 2000-01-02 20:14:01 +2359

Single-Letter Offsets

zone 값은 'A'..'I' 또는 'K'..'Z' 범위의 단일 문자일 수 있어요(군사 타임존 목록 참고).

t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
Time.at(t, in: 'A')                 # => 2000-01-01 21:15:01 +0100
Time.at(t, in: 'I')                 # => 2000-01-02 05:15:01 +0900
Time.at(t, in: 'K')                 # => 2000-01-02 06:15:01 +1000
Time.at(t, in: 'Y')                 # => 2000-01-01 08:15:01 -1200
Time.at(t, in: 'Z')                 # => 2000-01-01 20:15:01 UTC

Integer Offsets

zone 값은 -86399..86399 범위의 정수 초일 수 있어요.

t = Time.utc(2000, 1, 1, 20, 15, 1) # => 2000-01-01 20:15:01 UTC
Time.at(t, in: -86399)              # => 1999-12-31 20:15:02 -235959
Time.at(t, in: 86399)               # => 2000-01-02 20:15:00 +235959

Timezone Objects

zone 값은 특정 타임존 메서드에 응답하는 객체(예: Timezone, TZInfo의 인스턴스)일 수 있어요. 타임존 메서드는 아래와 같아요.

local_to_utc - Time.new가 위치 인자 zone이나 키워드 인자 in: 값으로 tz를 받고 호출될 때 호출돼요. 인자는 [Time-like 객체]이고, UTC 타임존의 [Time-like 객체]를 돌려줘요.
utc_to_local - Time.at이나 Time.now가 키워드 인자 in: 값으로 tz를 받고 호출될 때, 그리고 Time#getlocal이나 Time#localtime이 위치 인자 zone 값으로 tz를 받고 호출될 때 호출돼요. UTC 오프셋은 원래 시간과 반환된 객체의 차이를 Integer로 계산해서 구해요. 객체가 고정 오프셋이면 그 utc_offset도 셈에 포함돼요. 인자는 [Time-like 객체]이고, 로컬 타임존의 [Time-like 객체]를 돌려줘요.

커스텀 타임존 클래스는 정의돼 있다면 호출되는 인스턴스 메서드를 가질 수 있어요.

abbr - Time#strftime이 %Z가 포함된 형식으로 호출될 때 호출돼요. 인자는 [Time-like 객체]이고, 타임존 이름의 문자열 약자를 돌려줘요.
dst? - Time.at이나 Time.now가 키워드 인자 in: 값으로 tz를 받고 호출될 때, 그리고 Time#getlocal이나 Time#localtime이 위치 인자 zone 값으로 tz를 받고 호출될 때 호출돼요. 인자는 [Time-like 객체]이고, 일광 절약 시간인지 여부를 돌려줘요.
name - Marshal.dump(t)가 호출될 때 호출돼요. 인자는 없고, 타임존의 문자열 이름을 돌려줘요.

Time-like 객체

Time-like 객체는 타임존 변환을 위해 타임존 라이브러리와 인터페이스할 수 있는 컨테이너 객체예요. 위 타임존 변환 메서드의 인자는 Time과 비슷한 속성을 가지되, 타임존 관련 속성은 의미가 없어요. local_to_utc와 utc_to_local이 돌려주는 객체는 인자와 같은 클래스일 수도, 임의 객체 클래스일 수도, Integer 클래스일 수도 있어요. Integer가 아닌 클래스라면 그 클래스는 year, mon, mday, hour, min, sec, isdst, to_i 메서드를 가져야 해요. Integer를 돌려주면 그 구성 요소가 UTC로 분해되어 지정된 타임존의 시간으로 해석돼요.

Timezone Names

클래스(클래스 메서드의 수신자, 또는 인스턴스 메서드 수신자의 클래스)에 find_timezone 싱글턴 메서드가 있으면, 타임존 이름에서 해당 타임존 객체를 얻기 위해 이 메서드를 호출해요.

예를 들어 [Timezone]을 쓰는 경우:

class TimeWithTimezone < Time
  require 'timezone'
  def self.find_timezone(z) = Timezone[z]
end

TimeWithTimezone.now(in: "America/New_York")        #=> 2023-12-25 00:00:00 -0500
TimeWithTimezone.new("2023-12-25 America/New_York") #=> 2023-12-25 00:00:00 -0500

또는 [TZInfo]를 쓰는 경우:

class TimeWithTZInfo < Time
  require 'tzinfo'
  def self.find_timezone(z) = TZInfo::Timezone.get(z)
end

TimeWithTZInfo.now(in: "America/New_York")          #=> 2023-12-25 00:00:00 -0500
TimeWithTZInfo.new("2023-12-25 America/New_York")   #=> 2023-12-25 00:00:00 -0500

이 메서드는 서브클래스마다, 또는 최상위 Time 클래스에 정의할 수 있어요.

클래스 메서드 상세 (Public Class Methods)

`at(time, subsec = false, unit = :microsecond, in: nil)`

주어진 인자에 기반한 새 Time 객체를 돌려줘요. 필수 인자 time은 다음 중 하나일 수 있어요.

Time 객체(반환 time의 기준 값; 선택 키워드 인자 in:의 영향도 받음).
반환 time을 위한 에포크 초의 숫자 값.

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

선택 숫자 인자 subsec와 선택 심볼 인자 unit은 함께 작동해 반환 time의 서브초를 지정해요. unit은 subsec의 단위를 지정해요.

:millisecond - subsec을 밀리초로.

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 또는 :usec - subsec을 마이크로초로.

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 또는 :nsec - subsec을 나노초로.

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

선택 키워드 인자 in: zone은 반환 time의 타임존을 지정해요.

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

인자 zone의 형태는 [타임존 지정자]를 참고하세요.

`httpdate(date)`

RFC 2616이 정의하는 HTTP-date로 date를 파싱해 Time 객체로 변환해요. date가 RFC 2616에 맞지 않거나 Time 클래스가 지정된 날짜를 표현할 수 없으면 ArgumentError를 던져요. 이 형식에 대한 자세한 내용은 httpdate 인스턴스 메서드를 참고하세요.

require 'time'

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

이 메서드를 쓰려면 require 'time'이 필요해요.

`json_create(object)`

as_json을 참고하세요.

`local(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0) → new_time` / `local(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy) → new_time` (`mktime` 별칭)

Time.utc과 같되, 반환된 Time 객체가 UTC가 아니라 로컬 타임존이에요.

# 7개 인자로.
Time.local(0, 1, 2, 3, 4, 5, 6)
# => 0000-01-02 03:04:05.000006 -0600
# 정확히 10개 인자로.
Time.local(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
# => 0005-04-03 02:01:00 -0600

`new(year = nil, mon = nil, mday = nil, hour = nil, min = nil, sec = nil, zone = nil, in: nil, precision: 9)`

주어진 인자에 기반한 새 Time 객체를 돌려주며, 기본적으로 로컬 타임존이에요.

위치 인자가 없으면 Time.now의 값을 돌려줘요.

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

하나의 문자열 인자로 시간을 나타내면 그 인자에 기반한 새 Time 객체를 로컬 타임존으로 돌려줘요.

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

1개부터 6개까지의 인자로는 그 인자들에 기반한 새 Time 객체를 로컬 타임존으로 돌려줘요.

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

위치 인자에 대해(zone 제외):

year - 범위 제한이 없는 연도.

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

month - (1..12) 범위의 월, 또는 대소문자 무시 3글자 월 이름.

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 - (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 - (0..23) 범위의 시, 또는 min, sec, usec이 모두 0이면 24.

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 - (0..59) 범위의 분.

sec - (0...61) 범위의 초. Float나 Rational일 수도 있어요.

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
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

이 값들은 정수, 정수로 변환 가능한 숫자, String 정수일 수 있어요.

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

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

위치 인자 zone이나 키워드 인자 in:이 주어지면 새 Time 객체는 지정된 타임존이에요.

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

in: 키워드 인자는 단지 기본값을 제공하므로, 첫 인자가 단일 문자열 형태인데 그 안에 타임존 정보가 들어 있으면 이 키워드 인자는 조용히 무시돼요.

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

precision - 서브초 부분의 최대 유효 숫자, 기본값은 9. 더 많은 자릿수는 Time의 다른 연산처럼 잘려요. 첫 인자가 문자열일 때만 관련돼요.

`now(in: nil)`

현재 시스템 시간으로 새 Time 객체를 만들어요. 인자 없는 Time.new와 같아요.

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

`parse(date, now=self.now) { |year| ... }`

Time의 문자열 표현을 휴리스틱으로 파싱하려 시도해요. 이 메서드는 검증기(validator)로 동작하지 않아요. 입력 문자열이 유효한 형식과 엄격히 맞지 않으면 이해하기 어려운 결과를 얻을 수 있어요. 가능하면 Time.strptime을 쓰는 걸 고려하세요.

require 'time'

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

날짜의 빠진 부분은 현재 날짜를 기준으로 추론돼요.

require 'time'

# 현재 날짜를 "2011-10-31"로 가정
Time.parse("12:00") #=> 2011-10-31 12:00:00 -0500

빠진 요소를 추론하는 데 쓸 날짜는 mon, day, year에 응답하는 두 번째 객체를 넘겨 바꿀 수 있어요. Date, Time, DateTime 같은 것들 또는 직접 만든 객체도 됩니다.

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

블록을 주면 date에 기술된 연도를 블록이 변환해요. 이건 두 자리 연도를 처리하기 위해 특별히 설계된 거예요. 예를 들어 70보다 작은 모든 두 자리 연도를 2000년대로 처리하고 싶다면:

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

주어진 시간의 상위 요소가 부서지거나 빠지면 now의 것으로 채워져요. 하위 요소는 부서지거나 빠지면 최솟값(1 또는 0)을 가정해요.

require 'time'

# 지금이 "Thu Nov 29 14:33:20 2001"이고
# 타임존이 GMT-5인 EST라고 가정
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

전 세계에 지역 정의 타임존 약자가 워낙 많아서 이 메서드는 그 전부를 이해하려는 게 아니에요. 예를 들어 약자 "CST"는 America/Chicago에선 -06:00, America/Havana에선 -05:00, Asia/Harbin에선 +08:00, Australia/Darwin에선 +09:30, Australia/Adelaide에선 +10:30 등으로 다양하게 쓰여요. 그래서 이 메서드는 RFC 822에 기술된 타임존 약자와 시스템 타임존만, 이름이 나온 순서대로 이해해요. (즉, RFC 822의 정의가 시스템 타임존 정의를 덮어써요.) 시스템 타임존은 Time.local(year, 1, 1).zone과 Time.local(year, 7, 1).zone에서 가져와요. 추출된 타임존 약자가 그 중 어느 것과도 맞지 않으면 무시하고 주어진 시간을 로컬 시간으로 간주해요.

Date._parse가 date에서 정보를 추출할 수 없거나 Time 클래스가 지정된 날짜를 표현할 수 없으면 ArgumentError를 던져요. 이 메서드는 다른 파싱 메서드의 fail-safe로 쓸 수도 있어요.

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

다만 Time.parse의 실패까지 확인해야 해요. 이 메서드를 쓰려면 require 'time'이 필요해요.

`rfc2822(date)` (`rfc822` 별칭)

RFC 2822가 정의하는 date-time으로 date를 파싱해 Time 객체로 변환해요. 형식은 RFC 822가 정의하고 RFC 1123이 갱신한 날짜 형식과 동일해요. date가 RFC 2822에 맞지 않거나 Time 클래스가 표현할 수 없으면 ArgumentError를 던져요.

require 'time'

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

require 'time'이 필요해요.

`strptime(date, format, now=self.now) { |year| ... }`

parse와 비슷하게 동작하되, 휴리스틱으로 입력 문자열 형식을 감지하는 대신 형식을 기술하는 두 번째 인자 format을 제공해요. date나 format이 유효하지 않으면 ArgumentError를 던져요.

블록을 주면 date에 기술된 연도를 블록이 변환해요.

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

형식 옵션 목록은 아래와 같아요.

%a - 약식 요일 이름("Sun").
%A - 전체 요일 이름("Sunday").
%b - 약식 월 이름("Jan").
%B - 전체 월 이름("January").
%c - 선호하는 로컬 날짜·시간 표현.
%C - 세기(2009의 20).
%d - 일(01..31).
%D - 날짜(%m/%d/%y).
%e - 일, 공백 패딩( 1..31).
%F - %Y-%m-%d와 동일(ISO 8601 날짜 형식).
%g - 상업 연도의 마지막 두 자리.
%G - ISO-8601에 따른 주 기반 연도(1주차는 월요일에 시작하며 1월 4일을 포함).
%h - %b와 동일.
%H - 24시간 시(00..23).
%I - 12시간 시(01..12).
%j - 연중 일수(001..366).
%k - 24시간 시, 공백 패딩( 0..23).
%l - 12시간 시, 공백 패딩( 0..12).
%L - 초의 밀리초(000..999).
%m - 월(01..12).
%M - 시의 분(00..59).
%n - 개행(n).
%N - 분수 초 자릿수.
%p - 오전/오후 지시자("AM" 또는 "PM").
%P - 오전/오후 지시자("am" 또는 "pm").
%r - 12시간 시간(%I:%M:%S %p와 동일).
%R - 24시간 시간(%H:%M).
%s - 1970-01-01 00:00:00 UTC 이후의 초 수.
%S - 분의 초(00..60).
%t - 탭 문자(t).
%T - 24시간 시간(%H:%M:%S).
%u - 요일을 10진수로, 월요일이 1(1..7).
%U - 연중 주 번호, 첫 일요일이 첫 주의 첫 날(00..53).
%v - VMS 날짜(%e-%b-%Y).
%V - ISO 8601에 따른 연중 주 번호(01..53).
%W - 연중 주 번호, 첫 월요일이 첫 주의 첫 날(00..53).
%w - 요일(일요일 0, 0..6).
%x - 시간 없이 날짜만의 선호 표현.
%X - 날짜 없이 시간만의 선호 표현.
%y - 세기가 없는 연도(00..99).
%Y - 세기가 포함된 연도.
%z - UTC로부터의 시 오프셋 타임존(예: +0900).
%Z - 타임존 이름.
%% - 리터럴 "%" 문자.
%+ - 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

require 'time'이 필요해요.

`utc(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0) → new_time` / `utc(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy) → new_time` (`gm` 별칭)

주어진 인자에 기반한, UTC 타임존의 새 Time 객체를 돌려줘요.

1개에서 7개까지의 인자가 주어지면 첫 번째 호출 시퀀스로 해석돼요.

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

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

필수 인자 year에는 최소·최대 값이 없어요. 선택 인자에 대해:

month - (1..12) 범위의 월 또는 대소문자 무시 3글자 월 이름.
mday - (1..31) 범위의 일.
hour - (0..23) 범위의 시, 또는 min, sec, usec이 모두 0이면 24.
min - (0..59) 범위의 분.
sec - (0..59) 범위의 초, 또는 usec이 0이면 60.
usec - (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

값은 정수, 정수로 변환 가능한 숫자, String 정수일 수 있어요.

정확히 10개 인자가 주어지면 두 번째 호출 시퀀스로 해석돼요.

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

여기서 dummy 인자는 무시돼요.

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

이 형태는 Time.to_a가 돌려주는 10개 요소 배열로 Time 객체를 만드는 데 유용해요.

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

인자 수가 8, 9, 또는 10보다 크면 예외를 던져요. 관련: Time.local.

`xmlschema(time)` (`iso8601` 별칭)

XML Schema가 정의하는 dateTime으로 time을 파싱해 Time 객체로 변환해요. 형식은 ISO 8601의 제한된 버전이에요. time이 형식에 맞지 않거나 Time 클래스가 표현할 수 없으면 ArgumentError를 던져요.

require 'time'

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

require 'time'이 필요해요.

`zone_offset(zone, year=nil)`

지정된 타임존이 UTC와 다른 초 수를 돌려줘요. -10:00이나 +1330처럼 분을 포함하는 Numeric 타임존과, -10이나 +13 같은 간단한 시만의 타임존 모두 동작해요. ZoneOffset에 나열된 텍스트 타임존도 지원돼요.

타임존이 그 어느 것과도 맞지 않으면 zone_offset은 로컬 타임존(잠재적 일광 절약 시간 변경이 적용된 경우와 아닌 경우 모두)이 zone과 일치하는지 확인해요. year에 값을 지정하면 로컬 타임존을 찾는 데 쓰이는 연도를 바꿔요. 오프셋을 결정할 수 없으면 nil을 돌려줘요.

require 'time'

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

require 'time'이 필요해요.

인스턴스 메서드 상세 (Public Instance Methods)

`self + numeric → new_time`

self의 숫자 값과 주어진 numeric의 합을 값으로 하는 새 Time 객체를 돌려줘요.

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

`self - numeric → new_time` / `self - other_time → float`

numeric이 주어지면 self의 숫자 값과 numeric의 차를 값으로 하는 새 Time 객체를 돌려줘요.

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

other_time이 주어지면 self와 other_time의 숫자 값 차를 초 단위 Float로 돌려줘요.

t - t # => 0.0

`self <=> other_time → -1, 0, +1, or nil`

self와 other_time을 비교해요.

-1 - self가 other_time보다 작음.
0 - self가 other_time과 같음.
1 - self가 other_time보다 큼.
nil - self와 other_time을 비교할 수 없음.

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

`as_json(*)`

Time#as_json과 Time.json_create 메서드로 Time 객체를 직렬화·역직렬화할 수 있어요. Time#as_json은 self를 직렬화해 self를 나타내는 2-요소 해시를 돌려줘요.

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

JSON.create는 그런 해시를 역직렬화해 Time 객체를 돌려줘요.

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

또한 to_json은 self를 나타내는 JSON 문자열을 돌려줘요.

require 'json/add/time'
puts Time.now.to_json
# {"json_class":"Time","s":1700931678,"n":980650786}

`ceil(ndigits = 0) → new_time`

초를 ndigits 정밀도로 잘랐을 때 self보다 크거나 같은 숫자 값을 갖는 새 Time 객체를 돌려줘요.

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

`ctime → string` (`asctime` 별칭)

strftime('%a %b %e %T %Y') 또는 그 약칭 strftime('%c')로 포맷한 self의 문자열 표현을 돌려줘요.

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"

`deconstruct_keys(array_of_names_or_nil) → hash`

패턴 매칭에 쓰이는 이름/값 쌍의 해시를 돌려줘요. 가능한 키는 :year, :month, :day, :yday, :wday, :hour, :min, :sec, :subsec, :dst, :zone이에요.

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
#=> 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"

패턴에 의한 분해는 클래스 검사와 결합할 수도 있어요.

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

`dst? → true or false` (`isdst` 별칭)

self가 일광 절약 시간이면 true, 아니면 false를 돌려줘요.

t = Time.local(2000, 1, 1) # => 2000-01-01 00:00:00 -0600
t.zone                     # => "Central Standard Time"
t.dst?                     # => false
t = Time.local(2000, 7, 1) # => 2000-07-01 00:00:00 -0500
t.zone                     # => "Central Daylight Time"
t.dst?                     # => true

`eql?(other_time)`

self와 other_time이 모두 정확히 같은 시간 값을 가진 Time 객체면 true를 돌려줘요.

`floor(ndigits = 0) → new_time`

초를 ndigits 정밀도로 잘랐을 때 self보다 작거나 같은 숫자 값을 갖는 새 Time 객체를 돌려줘요.

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

`friday?`, `monday?`, `saturday?`, `sunday?`, `thursday?`, `tuesday?`, `wednesday? → true or false`

각각 self가 해당 요일이면 true, 아니면 false를 돌려줘요.

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

`getlocal(zone = nil) → new_time`

self의 값을 주어진 타임존으로 변환한 새 Time 객체를 돌려줘요. zone이 nil이면 로컬 타임존을 사용해요.

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

`getutc → new_time` (`getgm` 별칭)

self의 값을 UTC 타임존으로 변환한 새 Time 객체를 돌려줘요.

local = Time.local(2000) # => 2000-01-01 00:00:00 -0600
local.utc?               # => false
utc = local.getutc       # => 2000-01-01 06:00:00 UTC
utc.utc?                 # => true
utc == local             # => true

`gmtoff`/`gmt_offset`/`utc_offset → integer`

UTC와 self의 타임존 사이의 초 단위 오프셋을 돌려줘요.

Time.utc(2000, 1, 1).utc_offset   # => 0
Time.local(2000, 1, 1).utc_offset # => -21600 # -6*3600, 마이너스 6시간

`hash → integer`

self의 정수 해시 코드를 돌려줘요.

`hour`, `min`, `sec`, `year`, `mon`/`month`, `mday`/`day`, `wday`, `yday`

각각 해당하는 값을 정수로 돌려줘요: hour(0..23), min(0..59), sec(0..60, 윤초 시 60), year, mon(1..12), mday(1..31), wday(0..6, 일요일 0), yday(1..366).

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

`httpdate()`

RFC 2616이 정의하는 HTTP-date의 RFC 1123 날짜로 시간을 나타내는 문자열을 돌려줘요.

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

결과는 항상 UTC(GMT)라는 점에 주의하세요.

require 'time'

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

require 'time'이 필요해요.

`inspect → string`

서브초를 포함한 self의 문자열 표현을 돌려줘요.

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

`localtime → self or new_time` / `localtime(zone) → new_time`

인자 없이: self가 로컬 시간이면 self를, 아니면 사용자 로컬 타임존의 새 Time을 돌려줘요.

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

인자 zone이 주어지면 self를 주어진 타임존으로 변환해 만든 새 Time 객체를 돌려줘요.

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

`nsec → integer` (`tv_nsec` 별칭), `usec → integer` (`tv_usec` 별칭)

self의 서브초 부분의 나노초 수(0..999_999_999) / 마이크로초 수(0..999_999)를 돌려줘요. 낮은 자릿수는 반올림이 아니라 잘라내요.

t = Time.now # => 2022-07-11 15:04:53.3219637 -0500
t.nsec       # => 321963700
t.usec       # => 548469

정확한 서브초는 subsec을 참고하세요.

`rfc2822()` / `rfc822()`

RFC 2822가 정의하는 date-time으로 시간을 나타내는 문자열을 돌려줘요.

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

여기서 zone은 [+-]hhmm이에요. self가 UTC 시간이면 zone으로 -0000을 써요.

require 'time'

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

require 'time'이 필요해요.

`round(ndigits = 0) → new_time`

self의 숫자 값을 갖되 초 값을 ndigits 정밀도로 반올림한 새 Time 객체를 돌려줘요.

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(2) # => 2010-03-30 05:43:25.12 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.5).round  # => 2000-01-01 00:00:00 UTC
(t + 1.5).round  # => 2000-01-01 00:00:01 UTC

`strftime(format_string) → string`

주어진 문자열 format에 따라 포맷된 self의 문자열 표현을 돌려줘요. 형식은 strptime의 형식 옵션 목록을 참고하세요.

`subsec → numeric`

self의 정확한 서브초를 Numeric(Integer 또는 Rational)으로 돌려줘요.

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

서브초가 0이면 정수 0을 돌려줘요.

`to_a → array`

self를 나타내는 10개 요소 배열을 돌려줘요.

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]

반환 배열은 Time.utc이나 Time.local의 인자로 쓰기에 적합해요.

`to_date → date` / `to_datetime → datetime` / `to_time → time`

self를 나타내는 Date / DateTime 객체를 돌려줘요. to_time은 self를 돌려줘요.

`to_f → float`

self의 값을 [에포크 초]의 Float 수로 돌려줘요. 서브초가 포함돼요. self의 저장값은 Rational이므로 반환값이 근사치일 수 있어요.

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

`to_i → integer` (`tv_sec` 별칭)

self의 값을 정수 [에포크 초]로 돌려줘요. 서브초는 반올림이 아니라 잘라내요.

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

`to_r → rational`

self의 값을 [에포크 초]의 정확한 Rational 수로 돌려줘요.

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

`to_s → string`

서브초 없이 self의 문자열 표현을 돌려줘요.

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

`utc → self` (`gmtime` 별칭)

self를 UTC 타임존으로 변환해 돌려줘요.

t = Time.new(2000) # => 2000-01-01 00:00:00 -0600
t.utc?             # => false
t.utc              # => 2000-01-01 06:00:00 UTC
t.utc?             # => true

새로 변환된 객체를 돌려주는 getutc와는 달라요.

`utc? → true or false` (`gmt?` 별칭)

self가 UTC(GMT) 시간이면 true를 돌려줘요.

now = Time.now
now.utc? # => false
now.getutc.utc? # => true
utc = Time.utc(2000, 1, 1, 20, 15, 1)
utc.utc? # => true

Time.utc, Time#utc, Time#getutc로 만든 Time 객체는 UTC로 간주돼요. 다른 방식으로 만든 객체는 환경 변수 "TZ"가 "UTC"여도 UTC로 취급되지 않아요.

`xmlschema(fraction_digits=0)` / `iso8601(fraction_digits=0)`

XML Schema가 정의하는 dateTime으로 시간을 나타내는 문자열을 돌려줘요.

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

여기서 TZD는 Z 또는 [+-]hh:mm이에요. self가 UTC 시간이면 TZD로 Z를 써요. 그 외엔 [+-]hh:mm을 써요. fraction_digits는 분수 초에 쓸 자릿수를 지정하며 기본값은 0이에요.

require 'time'

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

require 'time'이 필요해요.

`zone → string or timezone`

self의 타임존 문자열 이름을 돌려줘요.

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

Time

Time (시간·날짜)

본문

에포크 초 (Epoch Seconds)

시간 해상도 (Time Resolution)

시간 내부 표현 (Time Internal Representation)

예시 (Examples)

새 Time 인스턴스 만들기

Time 인스턴스 다루기

뭐가 여기 있나 (What's Here)

만들기 (Methods for Creating)

값 가져오기 (Methods for Fetching)

질의하기 (Methods for Querying)

비교하기 (Methods for Comparing)

변환하기 (Methods for Converting)

반올림하기 (Methods for Rounding)

타임존 지정자 (Timezone Specifiers)

Hours/Minutes Offsets

Single-Letter Offsets

Integer Offsets

Timezone Objects

Time-like 객체

Timezone Names

클래스 메서드 상세 (Public Class Methods)

at(time, subsec = false, unit = :microsecond, in: nil)

httpdate(date)

json_create(object)

local(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0) → new_time / local(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy) → new_time (mktime 별칭)

new(year = nil, mon = nil, mday = nil, hour = nil, min = nil, sec = nil, zone = nil, in: nil, precision: 9)

now(in: nil)

parse(date, now=self.now) { |year| ... }

rfc2822(date) (rfc822 별칭)

strptime(date, format, now=self.now) { |year| ... }

utc(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0) → new_time / utc(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy) → new_time (gm 별칭)

xmlschema(time) (iso8601 별칭)

zone_offset(zone, year=nil)

인스턴스 메서드 상세 (Public Instance Methods)

self + numeric → new_time

self - numeric → new_time / self - other_time → float

self <=> other_time → -1, 0, +1, or nil

as_json(*)

ceil(ndigits = 0) → new_time

ctime → string (asctime 별칭)

deconstruct_keys(array_of_names_or_nil) → hash

dst? → true or false (isdst 별칭)

eql?(other_time)

floor(ndigits = 0) → new_time

friday?, monday?, saturday?, sunday?, thursday?, tuesday?, wednesday? → true or false

getlocal(zone = nil) → new_time

getutc → new_time (getgm 별칭)

gmtoff/gmt_offset/utc_offset → integer

hash → integer

hour, min, sec, year, mon/month, mday/day, wday, yday

httpdate()

inspect → string

localtime → self or new_time / localtime(zone) → new_time

nsec → integer (tv_nsec 별칭), usec → integer (tv_usec 별칭)

rfc2822() / rfc822()

round(ndigits = 0) → new_time

strftime(format_string) → string

subsec → numeric

to_a → array

to_date → date / to_datetime → datetime / to_time → time

to_f → float

to_i → integer (tv_sec 별칭)

to_r → rational

to_s → string

utc → self (gmtime 별칭)

utc? → true or false (gmt? 별칭)

xmlschema(fraction_digits=0) / iso8601(fraction_digits=0)

zone → string or timezone

새 `Time` 인스턴스 만들기

`Time` 인스턴스 다루기

`at(time, subsec = false, unit = :microsecond, in: nil)`

`httpdate(date)`

`json_create(object)`

`local(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0) → new_time` / `local(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy) → new_time` (`mktime` 별칭)

`new(year = nil, mon = nil, mday = nil, hour = nil, min = nil, sec = nil, zone = nil, in: nil, precision: 9)`

`now(in: nil)`

`parse(date, now=self.now) { |year| ... }`

`rfc2822(date)` (`rfc822` 별칭)

`strptime(date, format, now=self.now) { |year| ... }`

`utc(year, month = 1, mday = 1, hour = 0, min = 0, sec = 0, usec = 0) → new_time` / `utc(sec, min, hour, mday, month, year, dummy, dummy, dummy, dummy) → new_time` (`gm` 별칭)

`xmlschema(time)` (`iso8601` 별칭)

`zone_offset(zone, year=nil)`

`self + numeric → new_time`

`self - numeric → new_time` / `self - other_time → float`

`self <=> other_time → -1, 0, +1, or nil`

`as_json(*)`

`ceil(ndigits = 0) → new_time`

`ctime → string` (`asctime` 별칭)

`deconstruct_keys(array_of_names_or_nil) → hash`

`dst? → true or false` (`isdst` 별칭)

`eql?(other_time)`

`floor(ndigits = 0) → new_time`

`friday?`, `monday?`, `saturday?`, `sunday?`, `thursday?`, `tuesday?`, `wednesday? → true or false`

`getlocal(zone = nil) → new_time`

`getutc → new_time` (`getgm` 별칭)

`gmtoff`/`gmt_offset`/`utc_offset → integer`

`hash → integer`

`hour`, `min`, `sec`, `year`, `mon`/`month`, `mday`/`day`, `wday`, `yday`

`httpdate()`

`inspect → string`

`localtime → self or new_time` / `localtime(zone) → new_time`

`nsec → integer` (`tv_nsec` 별칭), `usec → integer` (`tv_usec` 별칭)

`rfc2822()` / `rfc822()`

`round(ndigits = 0) → new_time`

`strftime(format_string) → string`

`subsec → numeric`

`to_a → array`

`to_date → date` / `to_datetime → datetime` / `to_time → time`

`to_f → float`

`to_i → integer` (`tv_sec` 별칭)

`to_r → rational`

`to_s → string`

`utc → self` (`gmtime` 별칭)

`utc? → true or false` (`gmt?` 별칭)

`xmlschema(fraction_digits=0)` / `iso8601(fraction_digits=0)`

`zone → string or timezone`