In Files

  • time.c

Time

Time is an abstraction of dates and times. Time is stored internally as the number of seconds and nanoseconds since the Epoch, January 1, 1970 00:00 UTC. On some operating systems, this offset is allowed to be negative. Also see the library modules Date. The Time class treats GMT (Greenwich Mean Time) and UTC (Coordinated Universal Time)[Yes, UTC really does stand for Coordinated Universal Time. There was a committee involved.] as equivalent. GMT is the older way of referring to these baseline times but persists in the names of calls on POSIX systems.

All times are stored with some number of nanoseconds. Be aware of this fact when comparing times with each other—times that are apparently equal when displayed may be different when compared.

Public Class Methods

_load(string) => time click to toggle source

Unmarshal a dumped Time object.

 
               static VALUE
time_load(VALUE klass, VALUE str)
{
    VALUE time = time_s_alloc(klass);

    time_mload(time, str);
    return time;
}
            
at(time) => time click to toggle source
at(seconds_with_frac) => time
at(seconds, microseconds_with_frac) => time

Creates a new time object with the value given by time, the given number of seconds_with_frac, or seconds and microseconds_with_frac from the Epoch. seconds_with_frac and microseconds_with_frac can be Integer, Float, Rational, or other Numeric. non-portable feature allows the offset to be negative on some systems.

Time.at(0)            #=> 1969-12-31 18:00:00 -0600
Time.at(Time.at(0))   #=> 1969-12-31 18:00:00 -0600
Time.at(946702800)    #=> 1999-12-31 23:00:00 -0600
Time.at(-284061600)   #=> 1960-12-31 00:00:00 -0600
Time.at(946684800.2).usec #=> 200000
Time.at(946684800, 123456.789).nsec #=> 123456789
 
               static VALUE
time_s_at(int argc, VALUE *argv, VALUE klass)
{
    struct timespec ts;
    VALUE time, t;

    if (rb_scan_args(argc, argv, "11", &time, &t) == 2) {
        ts.tv_sec = NUM2LONG(time);
        ts.tv_nsec = NUM2LONG(rb_funcall(t, id_mul, 1, INT2FIX(1000)));
    }
    else {
        ts = rb_time_timespec(time);
    }
    t = time_new_internal(klass, ts.tv_sec, ts.tv_nsec);
    if (TYPE(time) == T_DATA && RDATA(time)->dfree == time_free) {
        struct time_object *tobj, *tobj2;

        GetTimeval(time, tobj);
        GetTimeval(t, tobj2);
        tobj2->gmt = tobj->gmt;
    }
    return t;
}
            
gm(year) => time click to toggle source
gm(year, month) => time
gm(year, month, day) => time
gm(year, month, day, hour) => time
gm(year, month, day, hour, min) => time
gm(year, month, day, hour, min, sec_with_frac) => time
gm(year, month, day, hour, min, sec, usec_with_frac) => time
gm(sec, min, hour, day, month, year, wday, yday, isdst, tz) => time

Creates a time based on given values, interpreted as UTC (GMT). The year must be specified. Other values default to the minimum value for that field (and may be nil or omitted). Months may be specified by numbers from 1 to 12, or by the three-letter English month names. Hours are specified on a 24-hour clock (0..23). Raises an ArgumentError if any values are out of range. Will also accept ten arguments in the order output by Time#to_a. sec_with_frac and usec_with_frac can have a fractional part.

Time.utc(2000,"jan",1,20,15,1)  #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
 
               static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
    return time_utc_or_local(argc, argv, Qtrue, klass);
}
            
local(year) => time click to toggle source
local(year, month) => time
local(year, month, day) => time
local(year, month, day, hour) => time
local(year, month, day, hour, min) => time
local(year, month, day, hour, min, sec_with_frac) => time
local(year, month, day, hour, min, sec, usec_with_frac) => time
local(sec, min, hour, day, month, year, wday, yday, isdst, tz) => time

Same as Time::gm, but interprets the values in the local time zone.

Time.local(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
 
               static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
    return time_utc_or_local(argc, argv, Qfalse, klass);
}
            
mktime(year) => time click to toggle source
mktime(year, month) => time
mktime(year, month, day) => time
mktime(year, month, day, hour) => time
mktime(year, month, day, hour, min) => time
mktime(year, month, day, hour, min, sec_with_frac) => time
mktime(year, month, day, hour, min, sec, usec_with_frac) => time
mktime(sec, min, hour, day, month, year, wday, yday, isdst, tz) => time

Same as Time::gm, but interprets the values in the local time zone.

Time.local(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
 
               static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
    return time_utc_or_local(argc, argv, Qfalse, klass);
}
            
new → time click to toggle source

Returns a Time object initialized to the current system time. Note: The object created will be created using the resolution available on your system clock, and so may include fractional seconds.

a = Time.new      #=> 2007-11-19 07:50:02 -0600
b = Time.new      #=> 2007-11-19 07:50:02 -0600
a == b            #=> false
"%.6f" % a.to_f   #=> "1195480202.282373"
"%.6f" % b.to_f   #=> "1195480202.283415"
 
               static VALUE
time_init(VALUE time)
{
    struct time_object *tobj;

    time_modify(time);
    GetTimeval(time, tobj);
    tobj->tm_got=0;
    tobj->ts.tv_sec = 0;
    tobj->ts.tv_nsec = 0;
#ifdef HAVE_CLOCK_GETTIME
    if (clock_gettime(CLOCK_REALTIME, &tobj->ts) == -1) {
        rb_sys_fail("clock_gettime");
    }
#else
    {
        struct timeval tv; 
        if (gettimeofday(&tv, 0) < 0) {
            rb_sys_fail("gettimeofday");
        }
        tobj->ts.tv_sec = tv.tv_sec;
        tobj->ts.tv_nsec = tv.tv_usec * 1000;
    }
#endif

    return time;
}
            
now(*args) click to toggle source

Synonym for Time.new. Returns a Time object initialized to the current system time.

utc(year) => time click to toggle source
utc(year, month) => time
utc(year, month, day) => time
utc(year, month, day, hour) => time
utc(year, month, day, hour, min) => time
utc(year, month, day, hour, min, sec_with_frac) => time
utc(year, month, day, hour, min, sec, usec_with_frac) => time
utc(sec, min, hour, day, month, year, wday, yday, isdst, tz) => time

Creates a time based on given values, interpreted as UTC (GMT). The year must be specified. Other values default to the minimum value for that field (and may be nil or omitted). Months may be specified by numbers from 1 to 12, or by the three-letter English month names. Hours are specified on a 24-hour clock (0..23). Raises an ArgumentError if any values are out of range. Will also accept ten arguments in the order output by Time#to_a. sec_with_frac and usec_with_frac can have a fractional part.

Time.utc(2000,"jan",1,20,15,1)  #=> 2000-01-01 20:15:01 UTC
Time.gm(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
 
               static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
    return time_utc_or_local(argc, argv, Qtrue, klass);
}
            

Public Instance Methods

time + numeric => time click to toggle source

Addition—Adds some number of seconds (possibly fractional) to time and returns that value as a new time.

t = Time.now         #=> 2007-11-19 08:22:21 -0600
t + (60 * 60 * 24)   #=> 2007-11-20 08:22:21 -0600
 
               static VALUE
time_plus(VALUE time1, VALUE time2)
{
    struct time_object *tobj;
    GetTimeval(time1, tobj);

    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        rb_raise(rb_eTypeError, "time + time?");
    }
    return time_add(tobj, time2, 1);
}
            
time - other_time => float click to toggle source
time - numeric => time

Difference—Returns a new time that represents the difference between two times, or subtracts the given number of seconds in numeric from time.

t = Time.now       #=> 2007-11-19 08:23:10 -0600
t2 = t + 2592000   #=> 2007-12-19 08:23:10 -0600
t2 - t             #=> 2592000.0
t2 - 2592000       #=> 2007-11-19 08:23:10 -0600
 
               static VALUE
time_minus(VALUE time1, VALUE time2)
{
    struct time_object *tobj;

    GetTimeval(time1, tobj);
    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        struct time_object *tobj2;
        double f;

        GetTimeval(time2, tobj2);
        if (tobj->ts.tv_sec < tobj2->ts.tv_sec)
            f = -(double)(unsigned_time_t)(tobj2->ts.tv_sec - tobj->ts.tv_sec);
        else
            f = (double)(unsigned_time_t)(tobj->ts.tv_sec - tobj2->ts.tv_sec);
        f += ((double)tobj->ts.tv_nsec - (double)tobj2->ts.tv_nsec)*1e-9;

        return DBL2NUM(f);
    }
    return time_add(tobj, time2, -1);
}
            
time <=> other_time => -1, 0, +1 click to toggle source

Comparison—Compares time with 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

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
 
               static VALUE
time_cmp(VALUE time1, VALUE time2)
{
    struct time_object *tobj1, *tobj2;

    GetTimeval(time1, tobj1);
    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        GetTimeval(time2, tobj2);
        if (tobj1->ts.tv_sec == tobj2->ts.tv_sec) {
            if (tobj1->ts.tv_nsec == tobj2->ts.tv_nsec) return INT2FIX(0);
            if (tobj1->ts.tv_nsec > tobj2->ts.tv_nsec) return INT2FIX(1);
            return INT2FIX(-1);
        }
        if (tobj1->ts.tv_sec > tobj2->ts.tv_sec) return INT2FIX(1);
        return INT2FIX(-1);
    }
    else {
        VALUE cmp;
        int n;

        cmp = rb_funcall(time2, rb_intern("<=>"), 1, time1);
        if (NIL_P(cmp)) return Qnil;

        n = -rb_cmpint(cmp, time1, time2);
        if (n == 0) return INT2FIX(0);
        if (n > 0) return INT2FIX(1);
        return INT2FIX(-1);
    }
}
            
_dump => string click to toggle source

Dump time for marshaling.

 
               static VALUE
time_dump(int argc, VALUE *argv, VALUE time)
{
    VALUE str;

    rb_scan_args(argc, argv, "01", 0);
    str = time_mdump(time); 

    return str;
}
            
asctime => string click to toggle source

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
 
               static VALUE
time_asctime(VALUE time)
{
    struct time_object *tobj;
    char *s;
    IF_HAVE_GMTIME_R(char buf[32]);

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    s = ASCTIME(&tobj->tm, buf);
    if (s[24] == '\n') s[24] = '\0';
#if (defined(_MSC_VER) && defined(_DLL)) || defined(__MSVCRT__)
    /* workaround for MSVCRT's bug */
    if (s[8] == '0') s[8] = ' ';
#endif

    return rb_str_new2(s);
}
            
ctime => string click to toggle source

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
 
               static VALUE
time_asctime(VALUE time)
{
    struct time_object *tobj;
    char *s;
    IF_HAVE_GMTIME_R(char buf[32]);

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    s = ASCTIME(&tobj->tm, buf);
    if (s[24] == '\n') s[24] = '\0';
#if (defined(_MSC_VER) && defined(_DLL)) || defined(__MSVCRT__)
    /* workaround for MSVCRT's bug */
    if (s[8] == '0') s[8] = ' ';
#endif

    return rb_str_new2(s);
}
            
day => fixnum click to toggle source

Returns the day of the month (1..n) for time.

t = Time.now   #=> 2007-11-19 08:27:03 -0600
t.day          #=> 19
t.mday         #=> 19
 
               static VALUE
time_mday(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mday);
}
            
dst? => true or false click to toggle source

Returns true if time occurs during Daylight Saving Time in its time zone.

# CST6CDT:
  Time.local(2000, 1, 1).zone    #=> "CST"
  Time.local(2000, 1, 1).isdst   #=> false
  Time.local(2000, 1, 1).dst?    #=> false
  Time.local(2000, 7, 1).zone    #=> "CDT"
  Time.local(2000, 7, 1).isdst   #=> true
  Time.local(2000, 7, 1).dst?    #=> true

# Asia/Tokyo:
  Time.local(2000, 1, 1).zone    #=> "JST"
  Time.local(2000, 1, 1).isdst   #=> false
  Time.local(2000, 1, 1).dst?    #=> false
  Time.local(2000, 7, 1).zone    #=> "JST"
  Time.local(2000, 7, 1).isdst   #=> false
  Time.local(2000, 7, 1).dst?    #=> false
 
               static VALUE
time_isdst(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return tobj->tm.tm_isdst?Qtrue:Qfalse;
}
            
eql?(other_time) click to toggle source

Return true if time and other_time are both Time objects with the same seconds and fractional seconds.

 
               static VALUE
time_eql(VALUE time1, VALUE time2)
{
    struct time_object *tobj1, *tobj2;

    GetTimeval(time1, tobj1);
    if (TYPE(time2) == T_DATA && RDATA(time2)->dfree == time_free) {
        GetTimeval(time2, tobj2);
        if (tobj1->ts.tv_sec == tobj2->ts.tv_sec) {
            if (tobj1->ts.tv_nsec == tobj2->ts.tv_nsec) return Qtrue;
        }
    }
    return Qfalse;
}
            
friday? => true or false click to toggle source

Returns true if time represents Friday.

t = Time.local(1987, 12, 18)     #=> 1987-12-18 00:00:00 -0600
t.friday?                        #=> true
 
               static VALUE
time_friday(VALUE time)
{
    wday_p(5);
}
            
getgm => new_time click to toggle source

Returns a new new_time object representing time in UTC.

t = Time.local(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
t.gmt?                             #=> false
y = t.getgm                        #=> 2000-01-02 02:15:01 UTC
y.gmt?                             #=> true
t == y                             #=> true
 
               static VALUE
time_getgmtime(VALUE time)
{
    return time_gmtime(time_dup(time));
}
            
getlocal => new_time click to toggle source

Returns a new new_time object representing time in local time (using the local time zone in effect for this process).

t = Time.gm(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
t.gmt?                          #=> true
l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
l.gmt?                          #=> false
t == l                          #=> true
 
               static VALUE
time_getlocaltime(VALUE time)
{
    return time_localtime(time_dup(time));
}
            
getutc => new_time click to toggle source

Returns a new new_time object representing time in UTC.

t = Time.local(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 -0600
t.gmt?                             #=> false
y = t.getgm                        #=> 2000-01-02 02:15:01 UTC
y.gmt?                             #=> true
t == y                             #=> true
 
               static VALUE
time_getgmtime(VALUE time)
{
    return time_gmtime(time_dup(time));
}
            
gmt? => true or false click to toggle source

Returns true if time represents a time in UTC (GMT).

t = Time.now                        #=> 2007-11-19 08:15:23 -0600
t.utc?                              #=> false
t = Time.gm(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
t.utc?                              #=> true

t = Time.now                        #=> 2007-11-19 08:16:03 -0600
t.gmt?                              #=> false
t = Time.gm(2000,1,1,20,15,1)       #=> 2000-01-01 20:15:01 UTC
t.gmt?                              #=> true
 
               static VALUE
time_utc_p(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->gmt) return Qtrue;
    return Qfalse;
}
            
gmt_offset => fixnum click to toggle source

Returns the offset in seconds between the timezone of time and UTC.

t = Time.gm(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
t.gmt_offset                    #=> 0
l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
l.gmt_offset                    #=> -21600
 
               static VALUE
time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return INT2FIX(0);
    }
    else {
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        return INT2NUM(tobj->tm.tm_gmtoff);
#else
        struct tm *u, *l;
        time_t t;
        long off;
        IF_HAVE_GMTIME_R(struct tm result);
        l = &tobj->tm;
        t = tobj->ts.tv_sec;
        u = GMTIME(&t, result);
        if (!u)
            rb_raise(rb_eArgError, "gmtime error");
        if (l->tm_year != u->tm_year)
            off = l->tm_year < u->tm_year ? -1 : 1;
        else if (l->tm_mon != u->tm_mon)
            off = l->tm_mon < u->tm_mon ? -1 : 1;
        else if (l->tm_mday != u->tm_mday)
            off = l->tm_mday < u->tm_mday ? -1 : 1;
        else
            off = 0;
        off = off * 24 + l->tm_hour - u->tm_hour;
        off = off * 60 + l->tm_min - u->tm_min;
        off = off * 60 + l->tm_sec - u->tm_sec;
        return LONG2FIX(off);
#endif
    }
}
            
gmtime => time click to toggle source

Converts time to UTC (GMT), modifying the receiver.

t = Time.now   #=> 2007-11-19 08:18:31 -0600
t.gmt?         #=> false
t.gmtime       #=> 2007-11-19 14:18:31 UTC
t.gmt?         #=> true

t = Time.now   #=> 2007-11-19 08:18:51 -0600
t.utc?         #=> false
t.utc          #=> 2007-11-19 14:18:51 UTC
t.utc?         #=> true
 
               static VALUE
time_gmtime(VALUE time)
{
    struct time_object *tobj;
    struct tm *tm_tmp;
    time_t t;
    IF_HAVE_GMTIME_R(struct tm result);

    GetTimeval(time, tobj);
    if (tobj->gmt) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }
    t = tobj->ts.tv_sec;
    tm_tmp = GMTIME(&t, result);
    if (!tm_tmp)
        rb_raise(rb_eArgError, "gmtime error");
    tobj->tm = *tm_tmp;
    tobj->tm_got = 1;
    tobj->gmt = 1;
    return time;
}
            
gmtoff => fixnum click to toggle source

Returns the offset in seconds between the timezone of time and UTC.

t = Time.gm(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
t.gmt_offset                    #=> 0
l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
l.gmt_offset                    #=> -21600
 
               static VALUE
time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return INT2FIX(0);
    }
    else {
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        return INT2NUM(tobj->tm.tm_gmtoff);
#else
        struct tm *u, *l;
        time_t t;
        long off;
        IF_HAVE_GMTIME_R(struct tm result);
        l = &tobj->tm;
        t = tobj->ts.tv_sec;
        u = GMTIME(&t, result);
        if (!u)
            rb_raise(rb_eArgError, "gmtime error");
        if (l->tm_year != u->tm_year)
            off = l->tm_year < u->tm_year ? -1 : 1;
        else if (l->tm_mon != u->tm_mon)
            off = l->tm_mon < u->tm_mon ? -1 : 1;
        else if (l->tm_mday != u->tm_mday)
            off = l->tm_mday < u->tm_mday ? -1 : 1;
        else
            off = 0;
        off = off * 24 + l->tm_hour - u->tm_hour;
        off = off * 60 + l->tm_min - u->tm_min;
        off = off * 60 + l->tm_sec - u->tm_sec;
        return LONG2FIX(off);
#endif
    }
}
            
hash => fixnum click to toggle source

Return a hash code for this time object.

 
               static VALUE
time_hash(VALUE time)
{
    struct time_object *tobj;
    long hash;

    GetTimeval(time, tobj);
    hash = tobj->ts.tv_sec ^ tobj->ts.tv_nsec;
    return LONG2FIX(hash);
}
            
hour => fixnum click to toggle source

Returns the hour of the day (0..23) for time.

t = Time.now   #=> 2007-11-19 08:26:20 -0600
t.hour         #=> 8
 
               static VALUE
time_hour(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_hour);
}
            
inspect => string click to toggle source

Returns a string representing time. Equivalent to calling Time#strftime with a format string of “%Y-%m-%d %H:%M:%S %z” for a local time and “%Y-%m-%d %H:%M:%S UTC” for a UTC time.

Time.now.to_s       #=> "2007-10-05 16:09:51 +0900"
Time.now.utc.to_s   #=> "2007-10-05 07:09:51 UTC"
 
               static VALUE
time_to_s(VALUE time)
{
    struct time_object *tobj;
    char buf[128];
    int len;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    if (tobj->gmt == 1) {
        len = rb_strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S UTC",
                          &tobj->tm, &tobj->ts, tobj->gmt);
    }
    else {
        len = rb_strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %z",
                          &tobj->tm, &tobj->ts, tobj->gmt);
    }
    return rb_str_new(buf, len);
}
            
isdst => true or false click to toggle source

Returns true if time occurs during Daylight Saving Time in its time zone.

# CST6CDT:
  Time.local(2000, 1, 1).zone    #=> "CST"
  Time.local(2000, 1, 1).isdst   #=> false
  Time.local(2000, 1, 1).dst?    #=> false
  Time.local(2000, 7, 1).zone    #=> "CDT"
  Time.local(2000, 7, 1).isdst   #=> true
  Time.local(2000, 7, 1).dst?    #=> true

# Asia/Tokyo:
  Time.local(2000, 1, 1).zone    #=> "JST"
  Time.local(2000, 1, 1).isdst   #=> false
  Time.local(2000, 1, 1).dst?    #=> false
  Time.local(2000, 7, 1).zone    #=> "JST"
  Time.local(2000, 7, 1).isdst   #=> false
  Time.local(2000, 7, 1).dst?    #=> false
 
               static VALUE
time_isdst(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return tobj->tm.tm_isdst?Qtrue:Qfalse;
}
            
localtime => time click to toggle source

Converts time to local time (using the local time zone in effect for this process) modifying the receiver.

t = Time.gm(2000, "jan", 1, 20, 15, 1)  #=> 2000-01-01 20:15:01 UTC
t.gmt?                                  #=> true
t.localtime                             #=> 2000-01-01 14:15:01 -0600
t.gmt?                                  #=> false
 
               static VALUE
time_localtime(VALUE time)
{
    struct time_object *tobj;
    struct tm *tm_tmp;
    time_t t;
    IF_HAVE_GMTIME_R(struct tm result);

    GetTimeval(time, tobj);
    if (!tobj->gmt) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }
    t = tobj->ts.tv_sec;
    tm_tmp = LOCALTIME(&t, result);
    if (!tm_tmp)
        rb_raise(rb_eArgError, "localtime error");
    tobj->tm = *tm_tmp;
    tobj->tm_got = 1;
    tobj->gmt = 0;
    return time;
}
            
marshal_dump() click to toggle source

undocumented

 
               static VALUE
time_mdump(VALUE time)
{
    struct time_object *tobj;
    struct tm *tm;
    unsigned long p, s;
    char buf[8];
    time_t t;
    int nsec;
    int i;
    VALUE str;
    IF_HAVE_GMTIME_R(struct tm result);

    GetTimeval(time, tobj);

    t = tobj->ts.tv_sec;
    tm = GMTIME(&t, result);

    if ((tm->tm_year & 0xffff) != tm->tm_year)
        rb_raise(rb_eArgError, "year too big to marshal: %ld", (long)tm->tm_year);

    p = 0x1UL        << 31 | /*  1 */
        tobj->gmt    << 30 | /*  1 */
        tm->tm_year  << 14 | /* 16 */
        tm->tm_mon   << 10 | /*  4 */
        tm->tm_mday  <<  5 | /*  5 */
        tm->tm_hour;         /*  5 */
    s = tm->tm_min   << 26 | /*  6 */
        tm->tm_sec   << 20 | /*  6 */
        tobj->ts.tv_nsec / 1000;    /* 20 */
    nsec = tobj->ts.tv_nsec % 1000;

    for (i=0; i<4; i++) {
        buf[i] = p & 0xff;
        p = RSHIFT(p, 8);
    }
    for (i=4; i<8; i++) {
        buf[i] = s & 0xff;
        s = RSHIFT(s, 8);
    }

    str = rb_str_new(buf, 8);
    rb_copy_generic_ivar(str, time);
    if (nsec) {
        /*
         * submicro is formatted in fixed-point packed BCD (without sign).
         * It represent digits under microsecond.
         * For nanosecond resolution, 3 digits (2 bytes) are used.
         * However it can be longer.
         * Extra digits are ignored for loading.
         */
        unsigned char buf[2];
        int len = sizeof(buf);
        buf[1] = (nsec % 10) << 4;
        nsec /= 10;
        buf[0] = nsec % 10;
        nsec /= 10;
        buf[0] |= (nsec % 10) << 4;
        if (buf[1] == 0)
            len = 1;
        rb_ivar_set(str, id_submicro, rb_str_new((char *)buf, len));
    }
    return str;
}
            
marshal_load(p1) click to toggle source

undocumented

 
               static VALUE
time_mload(VALUE time, VALUE str)
{
    struct time_object *tobj;
    unsigned long p, s;
    time_t sec;
    long usec;
    unsigned char *buf;
    struct tm tm;
    int i, gmt;
    long nsec;
    VALUE submicro;

    time_modify(time);

    submicro = rb_attr_get(str, id_submicro);
    if (submicro != Qnil) {
        st_delete(rb_generic_ivar_table(str), (st_data_t*)&id_submicro, 0);
    }
    rb_copy_generic_ivar(time, str);

    StringValue(str);
    buf = (unsigned char *)RSTRING_PTR(str);
    if (RSTRING_LEN(str) != 8) {
        rb_raise(rb_eTypeError, "marshaled time format differ");
    }

    p = s = 0;
    for (i=0; i<4; i++) {
        p |= buf[i]<<(8*i);
    }
    for (i=4; i<8; i++) {
        s |= buf[i]<<(8*(i-4));
    }

    if ((p & (1UL<<31)) == 0) {
        gmt = 0;
        sec = p;
        usec = s;
        nsec = usec * 1000;
    }
    else {
        p &= ~(1UL<<31);
        gmt        = (p >> 30) & 0x1;
        tm.tm_year = (p >> 14) & 0xffff;
        tm.tm_mon  = (p >> 10) & 0xf;
        tm.tm_mday = (p >>  5) & 0x1f;
        tm.tm_hour =  p        & 0x1f;
        tm.tm_min  = (s >> 26) & 0x3f;
        tm.tm_sec  = (s >> 20) & 0x3f;
        tm.tm_isdst = 0;

        sec = make_time_t(&tm, Qtrue);
        usec = (long)(s & 0xfffff);
        nsec = usec * 1000;

        if (submicro != Qnil) {
            unsigned char *ptr;
            long len;
            int digit;
            ptr = (unsigned char*)StringValuePtr(submicro);
            len = RSTRING_LEN(submicro);
            if (0 < len) {
                if (10 <= (digit = ptr[0] >> 4)) goto end_submicro;
                nsec += digit * 100;
                if (10 <= (digit = ptr[0] & 0xf)) goto end_submicro;
                nsec += digit * 10;
            }
            if (1 < len) {
                if (10 <= (digit = ptr[1] >> 4)) goto end_submicro;
                nsec += digit;
            }
end_submicro: ;
        }
    }
    time_overflow_p(&sec, &nsec);

    GetTimeval(time, tobj);
    tobj->tm_got = 0;
    tobj->gmt = gmt;
    tobj->ts.tv_sec = sec;
    tobj->ts.tv_nsec = nsec;

    return time;
}
            
mday => fixnum click to toggle source

Returns the day of the month (1..n) for time.

t = Time.now   #=> 2007-11-19 08:27:03 -0600
t.day          #=> 19
t.mday         #=> 19
 
               static VALUE
time_mday(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mday);
}
            
min => fixnum click to toggle source

Returns the minute of the hour (0..59) for time.

t = Time.now   #=> 2007-11-19 08:25:51 -0600
t.min          #=> 25
 
               static VALUE
time_min(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_min);
}
            
mon => fixnum click to toggle source
month => fixnum

Returns the month of the year (1..12) for time.

t = Time.now   #=> 2007-11-19 08:27:30 -0600
t.mon          #=> 11
t.month        #=> 11
 
               static VALUE
time_mon(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mon+1);
}
            
monday? => true or false click to toggle source

Returns true if time represents Monday.

t = Time.local(2003, 8, 4)       #=> 2003-08-04 00:00:00 -0500
p t.monday?                      #=> true
 
               static VALUE
time_monday(VALUE time)
{
    wday_p(1);
}
            
month => fixnum click to toggle source

Returns the month of the year (1..12) for time.

t = Time.now   #=> 2007-11-19 08:27:30 -0600
t.mon          #=> 11
t.month        #=> 11
 
               static VALUE
time_mon(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_mon+1);
}
            
nsec => int click to toggle source

Returns just the number of nanoseconds for time.

t = Time.now        #=> 2007-11-17 15:18:03 +0900
"%10.9f" % t.to_f   #=> "1195280283.536151409"
t.nsec              #=> 536151406

The lowest digit of #to_f and nsec is different because IEEE 754 double is not accurate enough to represent nanoseconds from the Epoch. The accurate value is returned by nsec.

 
               static VALUE
time_nsec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->ts.tv_nsec);
}
            
saturday? => true or false click to toggle source

Returns true if time represents Saturday.

t = Time.local(2006, 6, 10)      #=> 2006-06-10 00:00:00 -0500
t.saturday?                      #=> true
 
               static VALUE
time_saturday(VALUE time)
{
    wday_p(6);
}
            
sec => fixnum click to toggle source

Returns the second of the minute (0..60)[Yes, seconds really can range from zero to 60. This allows the system to inject leap seconds every now and then to correct for the fact that years are not really a convenient number of hours long.] for time.

t = Time.now   #=> 2007-11-19 08:25:02 -0600
t.sec          #=> 2
 
               static VALUE
time_sec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_sec);
}
            
strftime( string ) => string click to toggle source

Formats time according to the directives in the given format string. Any text not listed as a directive will be passed through to the output string.

Format meaning:

% - The abbreviated weekday name (%x`Sun'')
% - The  full  weekday  name (%x`Sunday'')
% - The abbreviated month name (%x`Jan'')
% - The  full  month  name (%x`January'')
% - The preferred local date and time representation
% - Day of the month (01..31)
% - Equivalent to %-%-% (the ISO 8601 date format)
% - Hour of the day, 24-hour clock (00..23)
% - Hour of the day, 12-hour clock (01..12)
% - Day of the year (001..366)
% - Millisecond of the second (000..999)
% - Month of the year (01..12)
% - Minute of the hour (00..59)
% - Fractional seconds digits, default is 9 digits (nanosecond)
        %N  millisecond (3 digits)
        %N  microsecond (6 digits)
        %N  nanosecond (9 digits)
% - Meridian indicator (%x`AM''  or  %x`PM'')
% - Meridian indicator (%x`am''  or  %x`pm'')
%s- Number of seconds since 1970-01-01 00:00:00 UTC.
%S - Second of the minute (00..60)
% - Week  number  of the current year,
        starting with the first Sunday as the first
        day of the first week (00..53)
%W- Week  number  of the current year,
        starting with the first Monday as the first
        day of the first week (00..53)
%w- Day of the week (Sunday is 0, 0..6)
%x- Preferred representation for the date alone, no time
% - Preferred representation for the time alone, no date
% - Year without a century (00..99)
% - Year with century
% - Time zone name
%Q - Literal ``%'' character

 t = Time.now                        #=> 2007-11-19 08:37:48 -0600
 t.strftime("Printed on %m/%d/%Y")   #=> "Printed on 11/19/2007"
 t.strftime("at %I:%M%p")            #=> "at 08:37AM"
 
               static VALUE
time_strftime(VALUE time, VALUE format)
{
    void rb_enc_copy(VALUE, VALUE);
    struct time_object *tobj;
    char buffer[SMALLBUF], *buf = buffer;
    const char *fmt;
    long len;
    VALUE str;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    StringValue(format);
    if (!rb_enc_str_asciicompat_p(format)) {
        rb_raise(rb_eArgError, "format should have ASCII compatible encoding");
    }
    format = rb_str_new4(format);
    fmt = RSTRING_PTR(format);
    len = RSTRING_LEN(format);
    if (len == 0) {
        rb_warning("strftime called with empty format string");
    }
    else if (strlen(fmt) < len) {
        /* Ruby string may contain \0's. */
        const char *p = fmt, *pe = fmt + len;

        str = rb_str_new(0, 0);
        while (p < pe) {
            len = rb_strftime_alloc(&buf, p, &tobj->tm, &tobj->ts, tobj->gmt);
            rb_str_cat(str, buf, len);
            p += strlen(p);
            if (buf != buffer) {
                xfree(buf);
                buf = buffer;
            }
            for (fmt = p; p < pe && !*p; ++p);
            if (p > fmt) rb_str_cat(str, fmt, p - fmt);
        }
        return str;
    }
    else {
        len = rb_strftime_alloc(&buf, RSTRING_PTR(format),
                                     &tobj->tm, &tobj->ts, tobj->gmt);
    }
    str = rb_str_new(buf, len);
    if (buf != buffer) xfree(buf);
    rb_enc_copy(str, format);
    return str;
}
            
succ => new_time click to toggle source

Return a new time object, one second later than time.

t = Time.now       #=> 2007-11-19 08:23:57 -0600
t.succ             #=> 2007-11-19 08:23:58 -0600
 
               static VALUE
time_succ(VALUE time)
{
    struct time_object *tobj;
    int gmt;

    GetTimeval(time, tobj);
    gmt = tobj->gmt;
    time = rb_time_nano_new(tobj->ts.tv_sec + 1, tobj->ts.tv_nsec);
    GetTimeval(time, tobj);
    tobj->gmt = gmt;
    return time;
}
            
sunday? => true or false click to toggle source

Returns true if time represents Sunday.

t = Time.local(1990, 4, 1)       #=> 1990-04-01 00:00:00 -0600
t.sunday?                        #=> true
 
               static VALUE
time_sunday(VALUE time)
{
    wday_p(0);
}
            
thursday? => true or false click to toggle source

Returns true if time represents Thursday.

t = Time.local(1995, 12, 21)     #=> 1995-12-21 00:00:00 -0600
p t.thursday?                    #=> true
 
               static VALUE
time_thursday(VALUE time)
{
    wday_p(4);
}
            
to_a => array click to toggle source

Returns a ten-element array of values for time: {[ sec, min, hour, day, month, year, wday, yday, isdst, zone ]}. See the individual methods for an explanation of the valid ranges of each value. The ten elements can be passed directly to Time::utc or Time::local to create a new Time.

t = Time.now     #=> 2007-11-19 08:36:01 -0600
now = t.to_a     #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]
 
               static VALUE
time_to_a(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return rb_ary_new3(10,
                    INT2FIX(tobj->tm.tm_sec),
                    INT2FIX(tobj->tm.tm_min),
                    INT2FIX(tobj->tm.tm_hour),
                    INT2FIX(tobj->tm.tm_mday),
                    INT2FIX(tobj->tm.tm_mon+1),
                    LONG2NUM((long)tobj->tm.tm_year+1900),
                    INT2FIX(tobj->tm.tm_wday),
                    INT2FIX(tobj->tm.tm_yday+1),
                    tobj->tm.tm_isdst?Qtrue:Qfalse,
                    time_zone(time));
}
            
to_f => float click to toggle source

Returns the value of time as a floating point number of seconds since the Epoch.

t = Time.now
"%10.5f" % t.to_f   #=> "1049896564.13654"
t.to_i              #=> 1049896564

Note that IEEE 754 double is not accurate enough to represent nanoseconds from the Epoch.

 
               static VALUE
time_to_f(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return DBL2NUM((double)tobj->ts.tv_sec+(double)tobj->ts.tv_nsec/1e9);
}
            
to_i => int click to toggle source

Returns the value of time as an integer number of seconds since the Epoch.

t = Time.now
"%10.5f" % t.to_f   #=> "1049896564.17839"
t.to_i              #=> 1049896564
 
               static VALUE
time_to_i(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->ts.tv_sec);
}
            
to_s => string click to toggle source

Returns a string representing time. Equivalent to calling Time#strftime with a format string of “%Y-%m-%d %H:%M:%S %z” for a local time and “%Y-%m-%d %H:%M:%S UTC” for a UTC time.

Time.now.to_s       #=> "2007-10-05 16:09:51 +0900"
Time.now.utc.to_s   #=> "2007-10-05 07:09:51 UTC"
 
               static VALUE
time_to_s(VALUE time)
{
    struct time_object *tobj;
    char buf[128];
    int len;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    if (tobj->gmt == 1) {
        len = rb_strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S UTC",
                          &tobj->tm, &tobj->ts, tobj->gmt);
    }
    else {
        len = rb_strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S %z",
                          &tobj->tm, &tobj->ts, tobj->gmt);
    }
    return rb_str_new(buf, len);
}
            
tuesday? => true or false click to toggle source

Returns true if time represents Tuesday.

t = Time.local(1991, 2, 19)      #=> 1991-02-19 00:00:00 -0600
p t.tuesday?                     #=> true
 
               static VALUE
time_tuesday(VALUE time)
{
    wday_p(2);
}
            
tv_nsec => int click to toggle source

Returns just the number of nanoseconds for time.

t = Time.now        #=> 2007-11-17 15:18:03 +0900
"%10.9f" % t.to_f   #=> "1195280283.536151409"
t.nsec              #=> 536151406

The lowest digit of #to_f and nsec is different because IEEE 754 double is not accurate enough to represent nanoseconds from the Epoch. The accurate value is returned by nsec.

 
               static VALUE
time_nsec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->ts.tv_nsec);
}
            
tv_sec => int click to toggle source

Returns the value of time as an integer number of seconds since the Epoch.

t = Time.now
"%10.5f" % t.to_f   #=> "1049896564.17839"
t.to_i              #=> 1049896564
 
               static VALUE
time_to_i(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->ts.tv_sec);
}
            
tv_usec => int click to toggle source

Returns just the number of microseconds for time.

t = Time.now        #=> 2007-11-19 08:03:26 -0600
"%10.6f" % t.to_f   #=> "1195481006.775195"
t.usec              #=> 775195
 
               static VALUE
time_usec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->ts.tv_nsec/1000);
}
            
usec => int click to toggle source

Returns just the number of microseconds for time.

t = Time.now        #=> 2007-11-19 08:03:26 -0600
"%10.6f" % t.to_f   #=> "1195481006.775195"
t.usec              #=> 775195
 
               static VALUE
time_usec(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    return LONG2NUM(tobj->ts.tv_nsec/1000);
}
            
gmtime => time click to toggle source
utc => time

Converts time to UTC (GMT), modifying the receiver.

t = Time.now   #=> 2007-11-19 08:18:31 -0600
t.gmt?         #=> false
t.gmtime       #=> 2007-11-19 14:18:31 UTC
t.gmt?         #=> true

t = Time.now   #=> 2007-11-19 08:18:51 -0600
t.utc?         #=> false
t.utc          #=> 2007-11-19 14:18:51 UTC
t.utc?         #=> true
 
               static VALUE
time_gmtime(VALUE time)
{
    struct time_object *tobj;
    struct tm *tm_tmp;
    time_t t;
    IF_HAVE_GMTIME_R(struct tm result);

    GetTimeval(time, tobj);
    if (tobj->gmt) {
        if (tobj->tm_got)
            return time;
    }
    else {
        time_modify(time);
    }
    t = tobj->ts.tv_sec;
    tm_tmp = GMTIME(&t, result);
    if (!tm_tmp)
        rb_raise(rb_eArgError, "gmtime error");
    tobj->tm = *tm_tmp;
    tobj->tm_got = 1;
    tobj->gmt = 1;
    return time;
}
            
utc? => true or false click to toggle source

Returns true if time represents a time in UTC (GMT).

t = Time.now                        #=> 2007-11-19 08:15:23 -0600
t.utc?                              #=> false
t = Time.gm(2000,"jan",1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
t.utc?                              #=> true

t = Time.now                        #=> 2007-11-19 08:16:03 -0600
t.gmt?                              #=> false
t = Time.gm(2000,1,1,20,15,1)       #=> 2000-01-01 20:15:01 UTC
t.gmt?                              #=> true
 
               static VALUE
time_utc_p(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->gmt) return Qtrue;
    return Qfalse;
}
            
utc_offset => fixnum click to toggle source

Returns the offset in seconds between the timezone of time and UTC.

t = Time.gm(2000,1,1,20,15,1)   #=> 2000-01-01 20:15:01 UTC
t.gmt_offset                    #=> 0
l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
l.gmt_offset                    #=> -21600
 
               static VALUE
time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return INT2FIX(0);
    }
    else {
#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
        return INT2NUM(tobj->tm.tm_gmtoff);
#else
        struct tm *u, *l;
        time_t t;
        long off;
        IF_HAVE_GMTIME_R(struct tm result);
        l = &tobj->tm;
        t = tobj->ts.tv_sec;
        u = GMTIME(&t, result);
        if (!u)
            rb_raise(rb_eArgError, "gmtime error");
        if (l->tm_year != u->tm_year)
            off = l->tm_year < u->tm_year ? -1 : 1;
        else if (l->tm_mon != u->tm_mon)
            off = l->tm_mon < u->tm_mon ? -1 : 1;
        else if (l->tm_mday != u->tm_mday)
            off = l->tm_mday < u->tm_mday ? -1 : 1;
        else
            off = 0;
        off = off * 24 + l->tm_hour - u->tm_hour;
        off = off * 60 + l->tm_min - u->tm_min;
        off = off * 60 + l->tm_sec - u->tm_sec;
        return LONG2FIX(off);
#endif
    }
}
            
wday => fixnum click to toggle source

Returns an integer representing the day of the week, 0..6, with Sunday == 0.

t = Time.now   #=> 2007-11-20 02:35:35 -0600
t.wday         #=> 2
t.sunday?      #=> false
t.monday?      #=> false
t.tuesday?     #=> true
t.wednesday?   #=> false
t.thursday?    #=> false
t.friday?      #=> false
t.saturday?    #=> false
 
               static VALUE
time_wday(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_wday);
}
            
wednesday? => true or false click to toggle source

Returns true if time represents Wednesday.

t = Time.local(1993, 2, 24)      #=> 1993-02-24 00:00:00 -0600
p t.wednesday?                   #=> true
 
               static VALUE
time_wednesday(VALUE time)
{
    wday_p(3);
}
            
yday => fixnum click to toggle source

Returns an integer representing the day of the year, 1..366.

t = Time.now   #=> 2007-11-19 08:32:31 -0600
t.yday         #=> 323
 
               static VALUE
time_yday(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return INT2FIX(tobj->tm.tm_yday+1);
}
            
year => fixnum click to toggle source

Returns the year for time (including the century).

t = Time.now   #=> 2007-11-19 08:27:51 -0600
t.year         #=> 2007
 
               static VALUE
time_year(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }
    return LONG2NUM((long)tobj->tm.tm_year+1900);
}
            
zone => string click to toggle source

Returns the name of the time zone used for time. As of Ruby 1.8, returns “UTC” rather than “GMT” for UTC times.

t = Time.gm(2000, "jan", 1, 20, 15, 1)
t.zone   #=> "UTC"
t = Time.local(2000, "jan", 1, 20, 15, 1)
t.zone   #=> "CST"
 
               static VALUE
time_zone(VALUE time)
{
    struct time_object *tobj;
#if !defined(HAVE_TM_ZONE) && (!defined(HAVE_TZNAME) || !defined(HAVE_DAYLIGHT))
    char buf[64];
    int len;
#endif
    
    GetTimeval(time, tobj);
    if (tobj->tm_got == 0) {
        time_get_tm(time, tobj->gmt);
    }

    if (tobj->gmt == 1) {
        return rb_str_new2("UTC");
    }
#if defined(HAVE_TM_ZONE)
    return rb_str_new2(tobj->tm.tm_zone);
#elif defined(HAVE_TZNAME) && defined(HAVE_DAYLIGHT)
    return rb_str_new2(tzname[daylight && tobj->tm.tm_isdst]);
#else
    len = rb_strftime(buf, sizeof(buf), "%Z",
                      &tobj->tm, &tobj->ts, tobj->gmt);
    return rb_str_new(buf, len);
#endif
}
            

Commenting is here to help enhance the documentation. For example, code samples, or clarification of the documentation.

If you have questions about Ruby or the documentation, please post to one of the Ruby mailing lists. You will get better, faster, help that way.

If you wish to post a correction of the docs, please do so, but also file bug report so that it can be corrected for the next release. Thank you.

If you want to help improve the Ruby documentation, please visit Documenting-ruby.org.

blog comments powered by Disqus