Class: Time

Inherits:
Object show all
Includes:
Comparable
Defined in:
time.c

Overview

Time is an abstraction of dates and times. Time is stored internally as the number of seconds with fraction since the Epoch, January 1, 1970 00:00 UTC. Also see the library module Date. The Time class treats GMT (Greenwich Mean Time) and UTC (Coordinated Universal Time) 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 may have fraction. Be aware of this fact when comparing times with each other – times that are apparently equal when displayed may be different when compared.

Since Ruby 1.9.2, Time implementation uses a signed 63 bit integer, Bignum or Rational. The integer is a number of nanoseconds since the Epoch which can represent 1823-11-12 to 2116-02-20. When Bignum or Rational is used (before 1823, after 2116, under nanosecond), Time works slower as when integer is used.

Examples

All of these examples were done using the EST timezone which is GMT-5.

Creating a new Time instance

You can create a new instance of Time with Time::new. This will use the current system time. Time::now is an alias for this. You can also pass parts of the time to Time::new such as year, month, minute, etc. When you want to construct a time this way you must pass at least a year. If you pass the year with nothing else time will default to January 1 of that year at 00:00:00 with the current system timezone. Here are some examples:

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

You can pass a UTC offset:

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

Or a timezone object:

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

You can also use Time::gm, Time::local and Time::utc to infer GMT, local and UTC timezones instead of using the current system setting.

You can also create a new time using Time::at which takes the number of seconds (or fraction of seconds) since the Unix Epoch.

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

Working with an instance of Time

Once you have an instance of Time there is a multitude of things you can do with it. Below are some examples. For all of the following examples, we will work on the assumption that you have done the following:

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

Was that a monday?

t.monday? #=> false

What year was that again?

t.year #=> 1993

Was it daylight savings at the time?

t.dst? #=> false

What’s the day a year later?

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

How many seconds was that since the Unix Epoch?

t.to_i #=> 730522800

You can also do standard functions like compare two times.

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

Timezone argument

A timezone argument must have local_to_utc and utc_to_local methods, and may have name, abbr, and dst? methods.

The local_to_utc method should convert a Time-like object from the timezone to UTC, and utc_to_local is the opposite. The result also should be a Time or Time-like object (not necessary to be the same class). The #zone of the result is just ignored. Time-like argument to these methods is similar to a Time object in UTC without sub-second; it has attribute readers for the parts, e.g. #year, #month, and so on, and epoch time readers, #to_i. The sub-second attributes are fixed as 0, and #utc_offset, #zone, #isdst, and their aliases are same as a Time object in UTC. Also #to_time, #+, and #- methods are defined.

The name method is used for marshaling. If this method is not defined on a timezone object, Time objects using that timezone object can not be dumped by Marshal.

The abbr method is used by ‘%Z’ in #strftime.

The dst? method is called with a Time value and should return whether the Time value is in daylight savings time in the zone.

Auto conversion to Timezone

At loading marshaled data, a timezone name will be converted to a timezone object by find_timezone class method, if the method is defined.

Similarly, that class method will be called when a timezone argument does not have the necessary methods mentioned above.

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Comparable

#<, #<=, #==, #>, #>=, #between?, #clamp

Constructor Details

#new ⇒ Time #new(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, tz = nil) ⇒ Time

Returns a Time object.

It is initialized to the current system time if no argument is given.

Note: The new object will use the resolution available on your system clock, and may include fractional seconds.

If one or more arguments are specified, the time is initialized to the specified time.

sec may have fraction if it is a rational.

tz specifies the timezone. It can be an offset from UTC, given either as a string such as “+09:00” or a single letter “A”..“Z” excluding “J” (so-called military time zone), or as a number of seconds such as 32400. Or it can be a timezone object, see Timezone argument for details.

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"

Time.new(2008,6,21, 13,30,0, "+09:00") #=> 2008-06-21 13:30:00 +0900

# A trip for RubyConf 2007
t1 = Time.new(2007,11,1,15,25,0, "+09:00") # JST (Narita)
t2 = Time.new(2007,11,1,12, 5,0, "-05:00") # CDT (Minneapolis)
t3 = Time.new(2007,11,1,13,25,0, "-05:00") # CDT (Minneapolis)
t4 = Time.new(2007,11,1,16,53,0, "-04:00") # EDT (Charlotte)
t5 = Time.new(2007,11,5, 9,24,0, "-05:00") # EST (Charlotte)
t6 = Time.new(2007,11,5,11,21,0, "-05:00") # EST (Detroit)
t7 = Time.new(2007,11,5,13,45,0, "-05:00") # EST (Detroit)
t8 = Time.new(2007,11,6,17,10,0, "+09:00") # JST (Narita)
(t2-t1)/3600.0                             #=> 10.666666666666666
(t4-t3)/3600.0                             #=> 2.466666666666667
(t6-t5)/3600.0                             #=> 1.95
(t8-t7)/3600.0                             #=> 13.416666666666666

Overloads:

  • #new ⇒ Time
  • #new(year, month = nil, day = nil, hour = nil, min = nil, sec = nil, tz = nil) ⇒ Time 


2428
2429
2430
2431
2432
2433
2434
2435
 
# File 'time.c', line 2428

static VALUE
time_init(int argc, VALUE *argv, VALUE time)
{
    if (argc == 0)
        return time_init_0(time);
    else
        return time_init_1(argc, argv, time);
}

Class Method Details

.at(time) ⇒ Time .at(seconds_with_frac) ⇒ Time .at(seconds, microseconds_with_frac) ⇒ Time .at(seconds, milliseconds, : millisecond) ⇒ Time .at(seconds, microseconds, : usec) ⇒ Time .at(seconds, microseconds, : microsecond) ⇒ Time .at(seconds, nanoseconds, : nsec) ⇒ Time .at(seconds, nanoseconds, : nanosecond) ⇒ Time .at(time) ⇒ Time .at(seconds_with_frac) ⇒ Time .at(seconds, microseconds_with_frac) ⇒ Time .at(seconds, milliseconds, : millisecond) ⇒ Time .at(seconds, microseconds, : usec) ⇒ Time .at(seconds, microseconds, : microsecond) ⇒ Time .at(seconds, nanoseconds, : nsec) ⇒ Time .at(seconds, nanoseconds, : nanosecond) ⇒ 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 since the Epoch. seconds_with_frac and microseconds_with_frac can be an Integer, Float, Rational, or other Numeric. non-portable feature allows the offset to be negative on some systems.

If in argument is given, the result is in that timezone or UTC offset, or if a numeric argument is given, the result is in local time.

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
Time.at(946684800, 123456789, :nsec).nsec #=> 123456789

Overloads:

  • .at(time) ⇒ Time

    Returns:

  • .at(seconds_with_frac) ⇒ Time

    Returns:

  • .at(seconds, microseconds_with_frac) ⇒ Time

    Returns:

  • .at(seconds, milliseconds, : millisecond) ⇒ Time

    Returns:

  • .at(seconds, microseconds, : usec) ⇒ Time

    Returns:

  • .at(seconds, microseconds, : microsecond) ⇒ Time

    Returns:

  • .at(seconds, nanoseconds, : nsec) ⇒ Time

    Returns:

  • .at(seconds, nanoseconds, : nanosecond) ⇒ Time

    Returns:

  • .at(time) ⇒ Time

    Returns:

  • .at(seconds_with_frac) ⇒ Time

    Returns:

  • .at(seconds, microseconds_with_frac) ⇒ Time

    Returns:

  • .at(seconds, milliseconds, : millisecond) ⇒ Time

    Returns:

  • .at(seconds, microseconds, : usec) ⇒ Time

    Returns:

  • .at(seconds, microseconds, : microsecond) ⇒ Time

    Returns:

  • .at(seconds, nanoseconds, : nsec) ⇒ Time

    Returns:

  • .at(seconds, nanoseconds, : nanosecond) ⇒ Time

    Returns:



2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817
2818
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828
2829
2830
2831
2832
2833
2834
2835
2836
2837
2838
2839
 
# File 'time.c', line 2805

static VALUE
time_s_at(int argc, VALUE *argv, VALUE klass)
{
    VALUE time, t, unit = Qundef, zone = Qundef, opts;
    VALUE vals[TMOPT_MAX_];
    wideval_t timew;

    argc = rb_scan_args(argc, argv, "12:", &time, &t, &unit, &opts);
    if (get_tmopt(opts, vals)) {
        zone = vals[0];
    }
    if (argc >= 2) {
        int scale = argc == 3 ? get_scale(unit) : 1000000;
        time = num_exact(time);
        t = num_exact(t);
        timew = wadd(rb_time_magnify(v2w(time)), wmulquoll(v2w(t), TIME_SCALE, scale));
        t = time_new_timew(klass, timew);
    }
    else if (IsTimeval(time)) {
  struct time_object *tobj, *tobj2;
        GetTimeval(time, tobj);
        t = time_new_timew(klass, tobj->timew);
  GetTimeval(t, tobj2);
        TZMODE_COPY(tobj2, tobj);
    }
    else {
        timew = rb_time_magnify(v2w(num_exact(time)));
        t = time_new_timew(klass, timew);
    }
    if (zone != Qundef) {
        time_zonelocal(t, zone);
    }

    return t;
}

.utc(year) ⇒ Time .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, dummy, dummy, dummy, dummy) ⇒ Time .gm(year) ⇒ Time .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, dummy, dummy, dummy, dummy) ⇒ Time

Creates a Time object 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

Overloads:

  • .utc(year) ⇒ Time

    Returns:

  • .utc(year, month) ⇒ Time

    Returns:

  • .utc(year, month, day) ⇒ Time

    Returns:

  • .utc(year, month, day, hour) ⇒ Time

    Returns:

  • .utc(year, month, day, hour, min) ⇒ Time

    Returns:

  • .utc(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .utc(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .utc(sec, min, hour, day, month, year, dummy, dummy, dummy, dummy) ⇒ Time

    Returns:

  • .gm(year) ⇒ Time

    Returns:

  • .gm(year, month) ⇒ Time

    Returns:

  • .gm(year, month, day) ⇒ Time

    Returns:

  • .gm(year, month, day, hour) ⇒ Time

    Returns:

  • .gm(year, month, day, hour, min) ⇒ Time

    Returns:

  • .gm(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .gm(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .gm(sec, min, hour, day, month, year, dummy, dummy, dummy, dummy) ⇒ Time

    Returns:



3464
3465
3466
3467
3468
3469
3470
3471
 
# File 'time.c', line 3464

static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
    struct vtm vtm;

    time_arg(argc, argv, &vtm);
    return time_gmtime(time_new_timew(klass, timegmw(&vtm)));
}

.local(year) ⇒ Time .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, dummy, dummy, isdst, dummy) ⇒ Time .mktime(year) ⇒ Time .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, dummy, dummy, isdst, dummy) ⇒ 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

Overloads:

  • .local(year) ⇒ Time

    Returns:

  • .local(year, month) ⇒ Time

    Returns:

  • .local(year, month, day) ⇒ Time

    Returns:

  • .local(year, month, day, hour) ⇒ Time

    Returns:

  • .local(year, month, day, hour, min) ⇒ Time

    Returns:

  • .local(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .local(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .local(sec, min, hour, day, month, year, dummy, dummy, isdst, dummy) ⇒ Time

    Returns:

  • .mktime(year) ⇒ Time

    Returns:

  • .mktime(year, month) ⇒ Time

    Returns:

  • .mktime(year, month, day) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour, min) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .mktime(sec, min, hour, day, month, year, dummy, dummy, isdst, dummy) ⇒ Time

    Returns:



3498
3499
3500
3501
3502
3503
3504
3505
 
# File 'time.c', line 3498

static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
    struct vtm vtm;

    time_arg(argc, argv, &vtm);
    return time_localtime(time_new_timew(klass, timelocalw(&vtm)));
}

.local(year) ⇒ Time .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, dummy, dummy, isdst, dummy) ⇒ Time .mktime(year) ⇒ Time .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, dummy, dummy, isdst, dummy) ⇒ 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

Overloads:

  • .local(year) ⇒ Time

    Returns:

  • .local(year, month) ⇒ Time

    Returns:

  • .local(year, month, day) ⇒ Time

    Returns:

  • .local(year, month, day, hour) ⇒ Time

    Returns:

  • .local(year, month, day, hour, min) ⇒ Time

    Returns:

  • .local(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .local(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .local(sec, min, hour, day, month, year, dummy, dummy, isdst, dummy) ⇒ Time

    Returns:

  • .mktime(year) ⇒ Time

    Returns:

  • .mktime(year, month) ⇒ Time

    Returns:

  • .mktime(year, month, day) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour, min) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .mktime(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .mktime(sec, min, hour, day, month, year, dummy, dummy, isdst, dummy) ⇒ Time

    Returns:



3498
3499
3500
3501
3502
3503
3504
3505
 
# File 'time.c', line 3498

static VALUE
time_s_mktime(int argc, VALUE *argv, VALUE klass)
{
    struct vtm vtm;

    time_arg(argc, argv, &vtm);
    return time_localtime(time_new_timew(klass, timelocalw(&vtm)));
}

.now ⇒ Time

Creates a new Time object for the current time. This is same as Time.new without arguments.

Time.now            #=> 2009-06-24 12:39:54 +0900

Returns:



2737
2738
2739
2740
2741
2742
2743
2744
2745
2746
2747
2748
 
# File 'time.c', line 2737

static VALUE
time_s_now(int argc, VALUE *argv, VALUE klass)
{
    VALUE vals[TMOPT_MAX_], opts, t, zone = Qundef;
    rb_scan_args(argc, argv, ":", &opts);
    if (get_tmopt(opts, vals)) zone = vals[TMOPT_IN];
    t = rb_class_new_instance(0, NULL, klass);
    if (zone != Qundef) {
        time_zonelocal(t, zone);
    }
    return t;
}

.utc(year) ⇒ Time .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, dummy, dummy, dummy, dummy) ⇒ Time .gm(year) ⇒ Time .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, dummy, dummy, dummy, dummy) ⇒ Time

Creates a Time object 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

Overloads:

  • .utc(year) ⇒ Time

    Returns:

  • .utc(year, month) ⇒ Time

    Returns:

  • .utc(year, month, day) ⇒ Time

    Returns:

  • .utc(year, month, day, hour) ⇒ Time

    Returns:

  • .utc(year, month, day, hour, min) ⇒ Time

    Returns:

  • .utc(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .utc(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .utc(sec, min, hour, day, month, year, dummy, dummy, dummy, dummy) ⇒ Time

    Returns:

  • .gm(year) ⇒ Time

    Returns:

  • .gm(year, month) ⇒ Time

    Returns:

  • .gm(year, month, day) ⇒ Time

    Returns:

  • .gm(year, month, day, hour) ⇒ Time

    Returns:

  • .gm(year, month, day, hour, min) ⇒ Time

    Returns:

  • .gm(year, month, day, hour, min, sec_with_frac) ⇒ Time

    Returns:

  • .gm(year, month, day, hour, min, sec, usec_with_frac) ⇒ Time

    Returns:

  • .gm(sec, min, hour, day, month, year, dummy, dummy, dummy, dummy) ⇒ Time

    Returns:



3464
3465
3466
3467
3468
3469
3470
3471
 
# File 'time.c', line 3464

static VALUE
time_s_mkutc(int argc, VALUE *argv, VALUE klass)
{
    struct vtm vtm;

    time_arg(argc, argv, &vtm);
    return time_gmtime(time_new_timew(klass, timegmw(&vtm)));
}

Instance Method Details

#+(numeric) ⇒ Time

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

t = Time.now         #=> 2007-11-19 08:22:21 -0600
t + (60 * 60 * 24)   #=> 2007-11-20 08:22:21 -0600

Returns:



4171
4172
4173
4174
4175
4176
4177
4178
4179
4180
4181
 
# File 'time.c', line 4171

static VALUE
time_plus(VALUE time1, VALUE time2)
{
    struct time_object *tobj;
    GetTimeval(time1, tobj);

    if (IsTimeval(time2)) {
  rb_raise(rb_eTypeError, "time + time?");
    }
    return time_add(tobj, time1, time2, 1);
}

#-(other_time) ⇒ Float #-(numeric) ⇒ Time

Difference — Returns a difference in seconds as a Float between time and other_time, 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

Overloads:



4198
4199
4200
4201
4202
4203
4204
4205
4206
4207
4208
4209
4210
4211
 
# File 'time.c', line 4198

static VALUE
time_minus(VALUE time1, VALUE time2)
{
    struct time_object *tobj;

    GetTimeval(time1, tobj);
    if (IsTimeval(time2)) {
  struct time_object *tobj2;

  GetTimeval(time2, tobj2);
        return rb_Float(rb_time_unmagnify_to_float(wsub(tobj->timew, tobj2->timew)));
    }
    return time_add(tobj, time1, time2, -1);
}

#<=>(other_time) ⇒ -1, ...

Comparison—Compares time with other_time.

-1, 0, +1 or nil depending on whether time is less than, equal to, or greater than other_time.

nil is returned if the two values are incomparable.

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

Returns:

  • (-1, 0, +1, nil) 


3687
3688
3689
3690
3691
3692
3693
3694
3695
3696
3697
3698
3699
3700
3701
3702
3703
3704
 
# File 'time.c', line 3687

static VALUE
time_cmp(VALUE time1, VALUE time2)
{
    struct time_object *tobj1, *tobj2;
    int n;

    GetTimeval(time1, tobj1);
    if (IsTimeval(time2)) {
  GetTimeval(time2, tobj2);
  n = wcmp(tobj1->timew, tobj2->timew);
    }
    else {
  return rb_invcmp(time1, time2);
    }
    if (n == 0) return INT2FIX(0);
    if (n > 0) return INT2FIX(1);
    return INT2FIX(-1);
}

#_dump(*args) ⇒ Object (private)

:nodoc:



5240
5241
5242
5243
5244
5245
5246
5247
5248
5249
 
# File 'time.c', line 5240

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

    rb_check_arity(argc, 0, 1);
    str = time_mdump(time);

    return str;
}

#asctime ⇒ String #ctime ⇒ String

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
Time.now.ctime     #=> "Wed Apr  9 08:56:03 2003"

Overloads:



4057
4058
4059
4060
4061
 
# File 'time.c', line 4057

static VALUE
time_asctime(VALUE time)
{
    return strftimev("%a %b %e %T %Y", time, rb_usascii_encoding());
}

#ceil([ndigits]) ⇒ Time

Ceils sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time object. ndigits should be zero or a positive integer.

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"

Returns:



4390
4391
4392
4393
4394
4395
4396
4397
4398
4399
4400
4401
4402
4403
4404
4405
4406
 
# File 'time.c', line 4390

static VALUE
time_ceil(int argc, VALUE *argv, VALUE time)
{
    VALUE ndigits, v, den;
    struct time_object *tobj;

    if (!rb_check_arity(argc, 0, 1) || NIL_P(ndigits = argv[0]))
        den = INT2FIX(1);
    else
        den = ndigits_denominator(ndigits);

    GetTimeval(time, tobj);
    v = w2v(rb_time_unmagnify(tobj->timew));

    v = modv(v, den);
    return time_add(tobj, time, subv(den, v), 1);
}

#asctime ⇒ String #ctime ⇒ String

Returns a canonical string representation of time.

Time.now.asctime   #=> "Wed Apr  9 08:56:03 2003"
Time.now.ctime     #=> "Wed Apr  9 08:56:03 2003"

Overloads:



4057
4058
4059
4060
4061
 
# File 'time.c', line 4057

static VALUE
time_asctime(VALUE time)
{
    return strftimev("%a %b %e %T %Y", time, rb_usascii_encoding());
}

#day ⇒ Integer #mday ⇒ Integer

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

Overloads:



4484
4485
4486
4487
4488
4489
4490
4491
4492
 
# File 'time.c', line 4484

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.mday);
}

#isdst ⇒ Boolean #dst? ⇒ Boolean

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

Overloads:

  • #isdst ⇒ Boolean

    Returns:

    • (Boolean)
  • #dst? ⇒ Boolean

    Returns:

    • (Boolean) 


4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
 
# File 'time.c', line 4728

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    if (tobj->vtm.isdst == VTM_ISDST_INITVAL) {
        rb_raise(rb_eRuntimeError, "isdst is not set yet");
    }
    return tobj->vtm.isdst ? Qtrue : Qfalse;
}

#eql?(other_time) ⇒ Boolean

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

Returns:

  • (Boolean) 


3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
 
# File 'time.c', line 3714

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

    GetTimeval(time1, tobj1);
    if (IsTimeval(time2)) {
  GetTimeval(time2, tobj2);
        return rb_equal(w2v(tobj1->timew), w2v(tobj2->timew));
    }
    return Qfalse;
}

#floor([ndigits]) ⇒ Time

Floors sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time object. ndigits should be zero or a positive integer.

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"

Returns:



4343
4344
4345
4346
4347
4348
4349
4350
4351
4352
4353
4354
4355
4356
4357
4358
4359
 
# File 'time.c', line 4343

static VALUE
time_floor(int argc, VALUE *argv, VALUE time)
{
    VALUE ndigits, v, den;
    struct time_object *tobj;

    if (!rb_check_arity(argc, 0, 1) || NIL_P(ndigits = argv[0]))
        den = INT2FIX(1);
    else
        den = ndigits_denominator(ndigits);

    GetTimeval(time, tobj);
    v = w2v(rb_time_unmagnify(tobj->timew));

    v = modv(v, den);
    return time_add(tobj, time, v, -1);
}

#friday? ⇒ Boolean

Returns true if time represents Friday.

t = Time.local(1987, 12, 18)     #=> 1987-12-18 00:00:00 -0600
t.friday?                        #=> true

Returns:

  • (Boolean) 


4661
4662
4663
4664
4665
 
# File 'time.c', line 4661

static VALUE
time_friday(VALUE time)
{
    wday_p(5);
}

#getgm ⇒ Time #getutc ⇒ Time

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

Overloads:



4029
4030
4031
4032
4033
 
# File 'time.c', line 4029

static VALUE
time_getgmtime(VALUE time)
{
    return time_gmtime(time_dup(time));
}

#getlocal ⇒ Time #getlocal(utc_offset) ⇒ Time #getlocal(timezone) ⇒ Time

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

If utc_offset is given, it is used instead of the local time. utc_offset can be given as a human-readable string (eg. "+09:00") or as a number of seconds (eg. 32400).

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

l = t.getlocal                  #=> 2000-01-01 14:15:01 -0600
l.utc?                          #=> false
t == l                          #=> true

j = t.getlocal("+09:00")        #=> 2000-01-02 05:15:01 +0900
j.utc?                          #=> false
t == j                          #=> true

k = t.getlocal(9*60*60)         #=> 2000-01-02 05:15:01 +0900
k.utc?                          #=> false
t == k                          #=> true

Overloads:

  • #getlocal ⇒ Time

    Returns:

  • #getlocal(utc_offset) ⇒ Time

    Returns:

  • #getlocal(timezone) ⇒ Time

    Returns:



3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
4005
4006
4007
4008
4009
4010
4011
4012
4013
 
# File 'time.c', line 3984

static VALUE
time_getlocaltime(int argc, VALUE *argv, VALUE time)
{
    VALUE off;

    if (rb_check_arity(argc, 0, 1) && !NIL_P(off = argv[0])) {
        VALUE zone = off;
        if (maybe_tzobj_p(zone)) {
            VALUE t = time_dup(time);
            if (zone_localtime(off, t)) return t;
        }

        if (NIL_P(off = utc_offset_arg(off))) {
            if (NIL_P(zone = find_timezone(time, zone))) invalid_utc_offset();
            time = time_dup(time);
            if (!zone_localtime(zone, time)) invalid_utc_offset();
            return time;
        }
        else if (off == UTC_ZONE) {
            return time_gmtime(time_dup(time));
        }
        validate_utc_offset(off);

        time = time_dup(time);
        time_set_utc_offset(time, off);
        return time_fixoff(time);
    }

    return time_localtime(time_dup(time));
}

#getgm ⇒ Time #getutc ⇒ Time

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

Overloads:



4029
4030
4031
4032
4033
 
# File 'time.c', line 4029

static VALUE
time_getgmtime(VALUE time)
{
    return time_gmtime(time_dup(time));
}

#utc? ⇒ Boolean #gmt? ⇒ Boolean

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

Overloads:

  • #utc? ⇒ Boolean

    Returns:

    • (Boolean)
  • #gmt? ⇒ Boolean

    Returns:

    • (Boolean) 


3745
3746
3747
3748
3749
3750
3751
3752
3753
 
# File 'time.c', line 3745

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

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj)) return Qtrue;
    return Qfalse;
}

#gmt_offset ⇒ Integer #gmtoff ⇒ Integer #utc_offset ⇒ Integer

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

Overloads:



4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
 
# File 'time.c', line 4790

VALUE
rb_time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);

    if (TZMODE_UTC_P(tobj)) {
  return INT2FIX(0);
    }
    else {
  MAKE_TM(time, tobj);
  return tobj->vtm.utc_offset;
    }
}

#gmtime ⇒ Time #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

Overloads:



3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
 
# File 'time.c', line 3898

static VALUE
time_gmtime(VALUE time)
{
    struct time_object *tobj;
    struct vtm vtm;

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj)) {
  if (tobj->tm_got)
      return time;
    }
    else {
  time_modify(time);
    }

    vtm.zone = rb_fstring_lit("UTC");
    GMTIMEW(tobj->timew, &vtm);
    tobj->vtm = vtm;

    tobj->tm_got = 1;
    TZMODE_SET_UTC(tobj);
    return time;
}

#gmt_offset ⇒ Integer #gmtoff ⇒ Integer #utc_offset ⇒ Integer

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

Overloads:



4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
 
# File 'time.c', line 4790

VALUE
rb_time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);

    if (TZMODE_UTC_P(tobj)) {
  return INT2FIX(0);
    }
    else {
  MAKE_TM(time, tobj);
  return tobj->vtm.utc_offset;
    }
}

#hash ⇒ Integer

Returns a hash code for this Time object.

See also Object#hash.

Returns:



3764
3765
3766
3767
3768
3769
3770
3771
 
# File 'time.c', line 3764

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

    GetTimeval(time, tobj);
    return rb_hash(w2v(tobj->timew));
}

#hour ⇒ Integer

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

t = Time.now   #=> 2007-11-19 08:26:20 -0600
t.hour         #=> 8

Returns:



4462
4463
4464
4465
4466
4467
4468
4469
4470
 
# File 'time.c', line 4462

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.hour);
}

#initialize_copy(time) ⇒ Object

:nodoc:



3774
3775
3776
3777
3778
3779
3780
3781
3782
3783
3784
3785
 
# File 'time.c', line 3774

static VALUE
time_init_copy(VALUE copy, VALUE time)
{
    struct time_object *tobj, *tcopy;

    if (!OBJ_INIT_COPY(copy, time)) return copy;
    GetTimeval(time, tobj);
    GetNewTimeval(copy, tcopy);
    MEMCPY(tcopy, tobj, struct time_object, 1);

    return copy;
}

#inspect ⇒ String

Returns a detailed string representing time. Unlike to_s, preserves nanoseconds in the representation for easier debugging.

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"

Returns:



4105
4106
4107
4108
4109
4110
4111
4112
4113
4114
4115
4116
4117
4118
4119
4120
4121
4122
4123
4124
4125
4126
4127
4128
4129
4130
4131
4132
4133
4134
4135
 
# File 'time.c', line 4105

static VALUE
time_inspect(VALUE time)
{
    struct time_object *tobj;
    VALUE str, subsec;

    GetTimeval(time, tobj);
    str = strftimev("%Y-%m-%d %H:%M:%S", time, rb_usascii_encoding());
    subsec = w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE)));
    if (FIXNUM_P(subsec) && FIX2LONG(subsec) == 0) {
    }
    else if (FIXNUM_P(subsec) && FIX2LONG(subsec) < TIME_SCALE) {
        long len;
        str = rb_enc_sprintf(rb_usascii_encoding(), "%"PRIsVALUE".%09ld", str, FIX2LONG(subsec));
        for (len=RSTRING_LEN(str); RSTRING_PTR(str)[len-1] == '0' && len > 0; len--)
            ;
        rb_str_resize(str, len);
    }
    else {
        rb_str_cat_cstr(str, " ");
        subsec = quov(subsec, INT2FIX(TIME_SCALE));
        rb_str_concat(str, rb_obj_as_string(subsec));
    }
    if (TZMODE_UTC_P(tobj)) {
        rb_str_cat_cstr(str, " UTC");
    }
    else {
        rb_str_concat(str, strftimev(" %z", time, rb_usascii_encoding()));
    }
    return str;
}

#isdst ⇒ Boolean #dst? ⇒ Boolean

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

Overloads:

  • #isdst ⇒ Boolean

    Returns:

    • (Boolean)
  • #dst? ⇒ Boolean

    Returns:

    • (Boolean) 


4728
4729
4730
4731
4732
4733
4734
4735
4736
4737
4738
4739
 
# File 'time.c', line 4728

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    if (tobj->vtm.isdst == VTM_ISDST_INITVAL) {
        rb_raise(rb_eRuntimeError, "isdst is not set yet");
    }
    return tobj->vtm.isdst ? Qtrue : Qfalse;
}

#localtime ⇒ Time #localtime(utc_offset) ⇒ Time

Converts time to local time (using the local time zone in effect at the creation time of time) modifying the receiver.

If utc_offset is given, it is used instead of the local time.

t = Time.utc(2000, "jan", 1, 20, 15, 1) #=> 2000-01-01 20:15:01 UTC
t.utc?                                  #=> true

t.localtime                             #=> 2000-01-01 14:15:01 -0600
t.utc?                                  #=> false

t.localtime("+09:00")                   #=> 2000-01-02 05:15:01 +0900
t.utc?                                  #=> false

If utc_offset is not given and time is local time, just returns the receiver.

Overloads:

  • #localtime ⇒ Time

    Returns:

  • #localtime(utc_offset) ⇒ Time

    Returns:



3868
3869
3870
3871
3872
3873
3874
3875
3876
3877
3878
 
# File 'time.c', line 3868

static VALUE
time_localtime_m(int argc, VALUE *argv, VALUE time)
{
    VALUE off;

    if (rb_check_arity(argc, 0, 1) && !NIL_P(off = argv[0])) {
        return time_zonelocal(time, off);
    }

    return time_localtime(time);
}

#marshal_dump ⇒ Object (private)

:nodoc:



5098
5099
5100
5101
5102
5103
5104
5105
5106
5107
5108
5109
5110
5111
5112
5113
5114
5115
5116
5117
5118
5119
5120
5121
5122
5123
5124
5125
5126
5127
5128
5129
5130
5131
5132
5133
5134
5135
5136
5137
5138
5139
5140
5141
5142
5143
5144
5145
5146
5147
5148
5149
5150
5151
5152
5153
5154
5155
5156
5157
5158
5159
5160
5161
5162
5163
5164
5165
5166
5167
5168
5169
5170
5171
5172
5173
5174
5175
5176
5177
5178
5179
5180
5181
5182
5183
5184
5185
5186
5187
5188
5189
5190
5191
5192
5193
5194
5195
5196
5197
5198
5199
5200
5201
5202
5203
5204
5205
5206
5207
5208
5209
5210
5211
5212
5213
5214
5215
5216
5217
5218
5219
5220
5221
5222
5223
5224
5225
5226
5227
5228
5229
5230
5231
5232
5233
5234
5235
5236
5237
 
# File 'time.c', line 5098

static VALUE
time_mdump(VALUE time)
{
    struct time_object *tobj;
    unsigned long p, s;
    char buf[base_dump_size + sizeof(long) + 1];
    int i;
    VALUE str;

    struct vtm vtm;
    long year;
    long usec, nsec;
    VALUE subsecx, nano, subnano, v, zone;

    VALUE year_extend = Qnil;
    const int max_year = 1900+0xffff;

    GetTimeval(time, tobj);

    gmtimew(tobj->timew, &vtm);

    if (FIXNUM_P(vtm.year)) {
        year = FIX2LONG(vtm.year);
        if (year > max_year) {
            year_extend = INT2FIX(year - max_year);
            year = max_year;
        }
        else if (year < 1900) {
            year_extend = LONG2NUM(1900 - year);
            year = 1900;
        }
    }
    else {
        if (rb_int_positive_p(vtm.year)) {
            year_extend = rb_int_minus(vtm.year, INT2FIX(max_year));
            year = max_year;
        }
        else {
            year_extend = rb_int_minus(INT2FIX(1900), vtm.year);
            year = 1900;
        }
    }

    subsecx = vtm.subsecx;

    nano = mulquov(subsecx, INT2FIX(1000000000), INT2FIX(TIME_SCALE));
    divmodv(nano, INT2FIX(1), &v, &subnano);
    nsec = FIX2LONG(v);
    usec = nsec / 1000;
    nsec = nsec % 1000;

    nano = addv(LONG2FIX(nsec), subnano);

    p = 0x1UL            << 31 | /*  1 */
  TZMODE_UTC_P(tobj) << 30 | /*  1 */
  (year-1900)      << 14 | /* 16 */
  (vtm.mon-1)      << 10 | /*  4 */
  vtm.mday         <<  5 | /*  5 */
  vtm.hour;                /*  5 */
    s = (unsigned long)vtm.min << 26 | /*  6 */
  vtm.sec          << 20 | /*  6 */
  usec;    /* 20 */

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

    if (!NIL_P(year_extend)) {
        /*
         * Append extended year distance from 1900..(1900+0xffff).  In
         * each cases, there is no sign as the value is positive.  The
         * format is length (marshaled long) + little endian packed
         * binary (like as Fixnum and Bignum).
         */
        size_t ysize = rb_absint_size(year_extend, NULL);
        char *p, *const buf_year_extend = buf + base_dump_size;
        if (ysize > LONG_MAX ||
            (i = ruby_marshal_write_long((long)ysize, buf_year_extend)) < 0) {
            rb_raise(rb_eArgError, "year too %s to marshal: %"PRIsVALUE" UTC",
                     (year == 1900 ? "small" : "big"), vtm.year);
        }
        i += base_dump_size;
        str = rb_str_new(NULL, i + ysize);
        p = RSTRING_PTR(str);
        memcpy(p, buf, i);
        p += i;
        rb_integer_pack(year_extend, p, ysize, 1, 0, INTEGER_PACK_LITTLE_ENDIAN);
    }
    else {
        str = rb_str_new(buf, base_dump_size);
    }
    rb_copy_generic_ivar(str, time);
    if (!rb_equal(nano, INT2FIX(0))) {
        if (RB_TYPE_P(nano, T_RATIONAL)) {
            rb_ivar_set(str, id_nano_num, RRATIONAL(nano)->num);
            rb_ivar_set(str, id_nano_den, RRATIONAL(nano)->den);
        }
        else {
            rb_ivar_set(str, id_nano_num, nano);
            rb_ivar_set(str, id_nano_den, INT2FIX(1));
        }
    }
    if (nsec) { /* submicro is only for Ruby 1.9.1 compatibility */
        /*
         * 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.
         */
        char buf[2];
        int len = (int)sizeof(buf);
        buf[1] = (char)((nsec % 10) << 4);
        nsec /= 10;
        buf[0] = (char)(nsec % 10);
        nsec /= 10;
        buf[0] |= (char)((nsec % 10) << 4);
        if (buf[1] == 0)
            len = 1;
        rb_ivar_set(str, id_submicro, rb_str_new(buf, len));
    }
    if (!TZMODE_UTC_P(tobj)) {
  VALUE off = rb_time_utc_offset(time), div, mod;
  divmodv(off, INT2FIX(1), &div, &mod);
  if (rb_equal(mod, INT2FIX(0)))
      off = rb_Integer(div);
  rb_ivar_set(str, id_offset, off);
    }
    zone = tobj->vtm.zone;
    if (maybe_tzobj_p(zone)) {
        zone = rb_funcallv(zone, id_name, 0, 0);
    }
    rb_ivar_set(str, id_zone, zone);
    return str;
}

#marshal_load(str) ⇒ Object (private)

:nodoc:



5274
5275
5276
5277
5278
5279
5280
5281
5282
5283
5284
5285
5286
5287
5288
5289
5290
5291
5292
5293
5294
5295
5296
5297
5298
5299
5300
5301
5302
5303
5304
5305
5306
5307
5308
5309
5310
5311
5312
5313
5314
5315
5316
5317
5318
5319
5320
5321
5322
5323
5324
5325
5326
5327
5328
5329
5330
5331
5332
5333
5334
5335
5336
5337
5338
5339
5340
5341
5342
5343
5344
5345
5346
5347
5348
5349
5350
5351
5352
5353
5354
5355
5356
5357
5358
5359
5360
5361
5362
5363
5364
5365
5366
5367
5368
5369
5370
5371
5372
5373
5374
5375
5376
5377
5378
5379
5380
5381
5382
5383
5384
5385
5386
5387
5388
5389
5390
5391
5392
5393
5394
5395
5396
5397
5398
5399
5400
5401
5402
5403
5404
5405
5406
5407
5408
5409
5410
5411
5412
5413
5414
 
# File 'time.c', line 5274

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 vtm vtm;
    int i, gmt;
    long nsec;
    VALUE submicro, nano_num, nano_den, offset, zone, year;
    wideval_t timew;

    time_modify(time);

#define get_attr(attr, iffound)      attr = rb_attr_delete(str, id_##attr);      if (!NIL_P(attr)) {    iffound;      }

    get_attr(nano_num, {});
    get_attr(nano_den, {});
    get_attr(submicro, {});
    get_attr(offset, (offset = rb_rescue(validate_utc_offset, offset, NULL, Qnil)));
    get_attr(zone, (zone = rb_rescue(validate_zone_name, zone, NULL, Qnil)));
    get_attr(year, {});

#undef get_attr

    rb_copy_generic_ivar(time, str);

    StringValue(str);
    buf = (unsigned char *)RSTRING_PTR(str);
    if (RSTRING_LEN(str) < base_dump_size) {
      invalid_format:
  rb_raise(rb_eTypeError, "marshaled time format differ");
    }

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

    if ((p & (1UL<<31)) == 0) {
        gmt = 0;
  offset = Qnil;
  sec = p;
  usec = s;
        nsec = usec * 1000;
        timew = wadd(rb_time_magnify(TIMET2WV(sec)), wmulquoll(WINT2FIXWV(usec), TIME_SCALE, 1000000));
    }
    else {
  p &= ~(1UL<<31);
  gmt        = (int)((p >> 30) & 0x1);

        if (NIL_P(year)) {
            year = INT2FIX(((int)(p >> 14) & 0xffff) + 1900);
        }
        if (RSTRING_LEN(str) > base_dump_size) {
            long len = RSTRING_LEN(str) - base_dump_size;
            long ysize = 0;
            VALUE year_extend;
            const char *ybuf = (const char *)(buf += base_dump_size);
            ysize = ruby_marshal_read_long(&ybuf, len);
            len -= ybuf - (const char *)buf;
            if (ysize < 0 || ysize > len) goto invalid_format;
            year_extend = rb_integer_unpack(ybuf, ysize, 1, 0, INTEGER_PACK_LITTLE_ENDIAN);
            if (year == INT2FIX(1900)) {
                year = rb_int_minus(year, year_extend);
            }
            else {
                year = rb_int_plus(year, year_extend);
            }
        }
        vtm.year = year;
  vtm.mon  = ((int)(p >> 10) & 0xf) + 1;
  vtm.mday = (int)(p >>  5) & 0x1f;
  vtm.hour = (int) p        & 0x1f;
  vtm.min  = (int)(s >> 26) & 0x3f;
  vtm.sec  = (int)(s >> 20) & 0x3f;
        vtm.utc_offset = INT2FIX(0);
  vtm.yday = vtm.wday = 0;
  vtm.isdst = 0;
  vtm.zone = rb_fstring_lit("");

  usec = (long)(s & 0xfffff);
        nsec = usec * 1000;


        vtm.subsecx = mulquov(LONG2FIX(nsec), INT2FIX(TIME_SCALE), LONG2FIX(1000000000));
        if (nano_num != Qnil) {
            VALUE nano = quov(num_exact(nano_num), num_exact(nano_den));
            vtm.subsecx = addv(vtm.subsecx, mulquov(nano, INT2FIX(TIME_SCALE), LONG2FIX(1000000000)));
        }
        else if (submicro != Qnil) { /* for Ruby 1.9.1 compatibility */
            unsigned char *ptr;
            long len;
            int digit;
            ptr = (unsigned char*)StringValuePtr(submicro);
            len = RSTRING_LEN(submicro);
            nsec = 0;
            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;
            }
            vtm.subsecx = addv(vtm.subsecx, mulquov(LONG2FIX(nsec), INT2FIX(TIME_SCALE), LONG2FIX(1000000000)));
end_submicro: ;
        }
        timew = timegmw(&vtm);
    }

    GetNewTimeval(time, tobj);
    tobj->tzmode = TIME_TZMODE_LOCALTIME;
    tobj->tm_got = 0;
    tobj->timew = timew;
    if (gmt) {
  TZMODE_SET_UTC(tobj);
    }
    else if (!NIL_P(offset)) {
  time_set_utc_offset(time, offset);
  time_fixoff(time);
    }
    if (!NIL_P(zone)) {
        zone = mload_zone(time, zone);
  tobj->vtm.zone = zone;
        zone_localtime(zone, time);
    }

    return time;
}

#day ⇒ Integer #mday ⇒ Integer

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

Overloads:



4484
4485
4486
4487
4488
4489
4490
4491
4492
 
# File 'time.c', line 4484

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.mday);
}

#min ⇒ Integer

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

t = Time.now   #=> 2007-11-19 08:25:51 -0600
t.min          #=> 25

Returns:



4442
4443
4444
4445
4446
4447
4448
4449
4450
 
# File 'time.c', line 4442

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.min);
}

#mon ⇒ Integer #month ⇒ Integer

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

Overloads:



4506
4507
4508
4509
4510
4511
4512
4513
4514
 
# File 'time.c', line 4506

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.mon);
}

#monday? ⇒ Boolean

Returns true if time represents Monday.

t = Time.local(2003, 8, 4)       #=> 2003-08-04 00:00:00 -0500
t.monday?                        #=> true

Returns:

  • (Boolean) 


4597
4598
4599
4600
4601
 
# File 'time.c', line 4597

static VALUE
time_monday(VALUE time)
{
    wday_p(1);
}

#mon ⇒ Integer #month ⇒ Integer

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

Overloads:



4506
4507
4508
4509
4510
4511
4512
4513
4514
 
# File 'time.c', line 4506

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.mon);
}

#nsec ⇒ Integer #tv_nsec ⇒ Integer

Returns 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 digits of #to_f and #nsec are different because IEEE 754 double is not accurate enough to represent the exact number of nanoseconds since the Epoch.

The more accurate value is returned by #nsec.

Overloads:



3625
3626
3627
3628
3629
3630
3631
3632
 
# File 'time.c', line 3625

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

    GetTimeval(time, tobj);
    return rb_to_int(w2v(wmulquoll(wmod(tobj->timew, WINT2WV(TIME_SCALE)), 1000000000, TIME_SCALE)));
}

#round([ndigits]) ⇒ Time

Rounds sub seconds to a given precision in decimal digits (0 digits by default). It returns a new Time object. ndigits should be zero or a positive integer.

require 'time'

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

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

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

Returns:



4293
4294
4295
4296
4297
4298
4299
4300
4301
4302
4303
4304
4305
4306
4307
4308
4309
4310
4311
4312
 
# File 'time.c', line 4293

static VALUE
time_round(int argc, VALUE *argv, VALUE time)
{
    VALUE ndigits, v, den;
    struct time_object *tobj;

    if (!rb_check_arity(argc, 0, 1) || NIL_P(ndigits = argv[0]))
        den = INT2FIX(1);
    else
        den = ndigits_denominator(ndigits);

    GetTimeval(time, tobj);
    v = w2v(rb_time_unmagnify(tobj->timew));

    v = modv(v, den);
    if (lt(v, quov(den, INT2FIX(2))))
        return time_add(tobj, time, v, -1);
    else
        return time_add(tobj, time, subv(den, v), 1);
}

#saturday? ⇒ Boolean

Returns true if time represents Saturday.

t = Time.local(2006, 6, 10)      #=> 2006-06-10 00:00:00 -0500
t.saturday?                      #=> true

Returns:

  • (Boolean) 


4677
4678
4679
4680
4681
 
# File 'time.c', line 4677

static VALUE
time_saturday(VALUE time)
{
    wday_p(6);
}

#sec ⇒ Integer

Returns the second of the minute (0..60) for time.

Note: Seconds range from zero to 60 to allow the system to inject leap seconds. See en.wikipedia.org/wiki/Leap_second for further details.

t = Time.now   #=> 2007-11-19 08:25:02 -0600
t.sec          #=> 2

Returns:



4422
4423
4424
4425
4426
4427
4428
4429
4430
 
# File 'time.c', line 4422

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.sec);
}

#strftime(string) ⇒ String

Formats time according to the directives in the given format string.

The directives begin with a percent (%) character. Any text not listed as a directive will be passed through to the output string.

The directive consists of a percent (%) character, zero or more flags, optional minimum field width, optional modifier and a conversion specifier as follows:

%<flags><width><modifier><conversion>

Flags:

-  don't pad a numerical output
_  use spaces for padding
0  use zeros for padding
^  upcase the result string
#  change case
:  use colons for %z

The minimum field width specifies the minimum width.

The modifiers are “E” and “O”. They are ignored.

Format directives:

Date (Year, Month, Day):
  Y - Year with century if provided, will pad result at least 4 digits.
          -0001, 0000, 1995, 2009, 14292, etc.
  %C - year / 100 (rounded down such as 20 in 2009)
  y - year % 100 (00..99)

  m - Month of the year, zero-padded (01..12)
          _m  blank-padded ( 1..12)
          %-m  no-padded (1..12)
  B - The full month name (``January'')
          %^B  uppercased (``JANUARY'')
  %b - The abbreviated month name (``Jan'')
          %^b  uppercased (``JAN'')
  h - Equivalent to %b

  d - Day of the month, zero-padded (01..31)
          %-d  no-padded (1..31)
  e - Day of the month, blank-padded ( 1..31)

  j - Day of the year (001..366)

Time (Hour, Minute, Second, Subsecond):
  H - Hour of the day, 24-hour clock, zero-padded (00..23)
  k - Hour of the day, 24-hour clock, blank-padded ( 0..23)
  I - Hour of the day, 12-hour clock, zero-padded (01..12)
  l - Hour of the day, 12-hour clock, blank-padded ( 1..12)
  P - Meridian indicator, lowercase (``am'' or ``pm'')
  p - Meridian indicator, uppercase (``AM'' or ``PM'')

  M - Minute of the hour (00..59)

  S - Second of the minute (00..60)

  L - Millisecond of the second (000..999)
       The digits under millisecond are truncated to not produce 1000.
  %N - Fractional seconds digits, default is 9 digits (nanosecond)
          3N  millisecond (3 digits)
          6N  microsecond (6 digits)
          9N  nanosecond (9 digits)
          12N picosecond (12 digits)
          15N femtosecond (15 digits)
          18N attosecond (18 digits)
          21N zeptosecond (21 digits)
          24N yoctosecond (24 digits)
       The digits under the specified length are truncated to avoid
       carry up.

Time zone:
  z - Time zone as hour and minute offset from UTC (e.g. +0900)
          %:z - hour and minute offset from UTC with a colon (e.g. +09:00)
          %::z - hour, minute and second offset from UTC (e.g. +09:00:00)
  Z - Abbreviated time zone name or similar information.  (OS dependent)

Weekday:
  A - The full weekday name (``Sunday'')
          %^A  uppercased (``SUNDAY'')
  %a - The abbreviated name (``Sun'')
          %^a  uppercased (``SUN'')
  u - Day of the week (Monday is 1, 1..7)
  %w - Day of the week (Sunday is 0, 0..6)

ISO 8601 week-based year and week number:
The first week of YYYY starts with a Monday and includes YYYY-01-04.
The days in the year before the first week are in the last week of
the previous year.
  %G - The week-based year
  g - The last 2 digits of the week-based year (00..99)
  V - Week number of the week-based year (01..53)

Week number:
The first week of YYYY that starts with a Sunday or Monday (according to %U
or %W). The days in the year before the first week are in week 0.
  %U - Week number of the year. The week starts with Sunday. (00..53)
  %W - Week number of the year. The week starts with Monday. (00..53)

Seconds since the Epoch:
  s - Number of seconds since 1970-01-01 00:00:00 UTC.

Literal string:
  n - Newline character (\n)
  t - Tab character (\t)
  %% - Literal ``%'' character

Combination:
  c - date and time (a b %e T %Y)
  D - Date (m/d/y)
  F - The ISO 8601 date format (Y-m-d)
  v - VMS date (e-%^b-%4Y)
  %x - Same as %D
  %X - Same as %T
  %r - 12-hour time (%I:%M:%S %p)
  %R - 24-hour time (%H:%M)
  %T - 24-hour time (%H:%M:%S)

This method is similar to strftime() function defined in ISO C and POSIX.

While all directives are locale independent since Ruby 1.9, %Z is platform dependent. So, the result may differ even if the same format string is used in other systems such as C.

%z is recommended over %Z. %Z doesn’t identify the timezone. For example, “CST” is used at America/Chicago (-06:00), America/Havana (-05:00), Asia/Harbin (+08:00), Australia/Darwin (+09:30) and Australia/Adelaide (+10:30). Also, %Z is highly dependent on the operating system. For example, it may generate a non ASCII string on Japanese Windows, i.e. the result can be different to “JST”. So the numeric time zone offset, %z, is recommended.

Examples:

t = Time.new(2007,11,19,8,37,48,"-06:00") #=> 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:37 AM"

Various ISO 8601 formats:

Y%m%d           => 20071119                  Calendar date (basic)
F               => 2007-11-19                Calendar date (extended)
Y-m            => 2007-11                   Calendar date, reduced accuracy, specific month
Y               => 2007                      Calendar date, reduced accuracy, specific year
C               => 20                        Calendar date, reduced accuracy, specific century
Y%j             => 2007323                   Ordinal date (basic)
Y-j            => 2007-323                  Ordinal date (extended)
GW%V%u          => 2007W471                  Week date (basic)
G-W%V-u        => 2007-W47-1                Week date (extended)
GW%V            => 2007W47                   Week date, reduced accuracy, specific week (basic)
G-W%V           => 2007-W47                  Week date, reduced accuracy, specific week (extended)
H%M%S           => 083748                    Local time (basic)
T               => 08:37:48                  Local time (extended)
H%M             => 0837                      Local time, reduced accuracy, specific minute (basic)
H:%M            => 08:37                     Local time, reduced accuracy, specific minute (extended)
H               => 08                        Local time, reduced accuracy, specific hour
H%M%S,L        => 083748,000                Local time with decimal fraction, comma as decimal sign (basic)
T,L            => 08:37:48,000              Local time with decimal fraction, comma as decimal sign (extended)
H%M%S.%L        => 083748.000                Local time with decimal fraction, full stop as decimal sign (basic)
T.%L            => 08:37:48.000              Local time with decimal fraction, full stop as decimal sign (extended)
H%M%S%z         => 083748-0600               Local time and the difference from UTC (basic)
T%:z            => 08:37:48-06:00            Local time and the difference from UTC (extended)
Y%m%dT%H%M%S%z  => 20071119T083748-0600      Date and time of day for calendar date (basic)
FT%T%:z         => 2007-11-19T08:37:48-06:00 Date and time of day for calendar date (extended)
Y%jT%H%M%S%z    => 2007323T083748-0600       Date and time of day for ordinal date (basic)
Y-jT%T%:z      => 2007-323T08:37:48-06:00   Date and time of day for ordinal date (extended)
GW%V%uT%H%M%S%z => 2007W471T083748-0600      Date and time of day for week date (basic)
G-W%V-uT%T%:z  => 2007-W47-1T08:37:48-06:00 Date and time of day for week date (extended)
Y%m%dT%H%M      => 20071119T0837             Calendar date and local time (basic)
FT%R            => 2007-11-19T08:37          Calendar date and local time (extended)
Y%jT%H%MZ       => 2007323T0837Z             Ordinal date and UTC of day (basic)
Y-jT%RZ        => 2007-323T08:37Z           Ordinal date and UTC of day (extended)
GW%V%uT%H%M%z   => 2007W471T0837-0600        Week date and local time and difference from UTC (basic)
G-W%V-uT%R%:z  => 2007-W47-1T08:37-06:00    Week date and local time and difference from UTC (extended)

Returns:



5061
5062
5063
5064
5065
5066
5067
5068
5069
5070
5071
5072
5073
5074
5075
5076
5077
5078
5079
5080
5081
5082
5083
5084
5085
5086
5087
5088
5089
5090
5091
 
# File 'time.c', line 5061

static VALUE
time_strftime(VALUE time, VALUE format)
{
    struct time_object *tobj;
    const char *fmt;
    long len;
    rb_encoding *enc;
    VALUE tmp;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    StringValue(format);
    if (!rb_enc_str_asciicompat_p(format)) {
  rb_raise(rb_eArgError, "format should have ASCII compatible encoding");
    }
    tmp = rb_str_tmp_frozen_acquire(format);
    fmt = RSTRING_PTR(tmp);
    len = RSTRING_LEN(tmp);
    enc = rb_enc_get(format);
    if (len == 0) {
  rb_warning("strftime called with empty format string");
  return rb_enc_str_new(0, 0, enc);
    }
    else {
        VALUE str = rb_strftime_alloc(fmt, len, enc, time, &tobj->vtm, tobj->timew,
              TZMODE_UTC_P(tobj));
  rb_str_tmp_frozen_release(format, tmp);
  if (!str) rb_raise(rb_eArgError, "invalid format: %"PRIsVALUE, format);
  return str;
    }
}

#subsec ⇒ Numeric

Returns the fraction for time.

The return value can be a rational number.

t = Time.now        #=> 2009-03-26 22:33:12 +0900
"%10.9f" % t.to_f   #=> "1238074392.940563917"
t.subsec            #=> (94056401/100000000)

The lowest digits of #to_f and #subsec are different because IEEE 754 double is not accurate enough to represent the rational number.

The more accurate value is returned by #subsec.

Returns:



3653
3654
3655
3656
3657
3658
3659
3660
 
# File 'time.c', line 3653

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

    GetTimeval(time, tobj);
    return quov(w2v(wmod(tobj->timew, WINT2FIXWV(TIME_SCALE))), INT2FIX(TIME_SCALE));
}

#succ ⇒ Object

#sunday? ⇒ Boolean

Returns true if time represents Sunday.

t = Time.local(1990, 4, 1)       #=> 1990-04-01 00:00:00 -0600
t.sunday?                        #=> true

Returns:

  • (Boolean) 


4581
4582
4583
4584
4585
 
# File 'time.c', line 4581

static VALUE
time_sunday(VALUE time)
{
    wday_p(0);
}

#thursday? ⇒ Boolean

Returns true if time represents Thursday.

t = Time.local(1995, 12, 21)     #=> 1995-12-21 00:00:00 -0600
t.thursday?                      #=> true

Returns:

  • (Boolean) 


4645
4646
4647
4648
4649
 
# File 'time.c', line 4645

static VALUE
time_thursday(VALUE time)
{
    wday_p(4);
}

#to_a ⇒ Array

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

t = Time.now     #=> 2007-11-19 08:36:01 -0600
now = t.to_a     #=> [1, 36, 8, 19, 11, 2007, 1, 323, false, "CST"]

Returns:



4823
4824
4825
4826
4827
4828
4829
4830
4831
4832
4833
4834
4835
4836
4837
4838
4839
4840
4841
 
# File 'time.c', line 4823

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return rb_ary_new3(10,
        INT2FIX(tobj->vtm.sec),
        INT2FIX(tobj->vtm.min),
        INT2FIX(tobj->vtm.hour),
        INT2FIX(tobj->vtm.mday),
        INT2FIX(tobj->vtm.mon),
        tobj->vtm.year,
        INT2FIX(tobj->vtm.wday),
        INT2FIX(tobj->vtm.yday),
        tobj->vtm.isdst?Qtrue:Qfalse,
        time_zone(time));
}

#to_f ⇒ Float

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

t = Time.now
"%10.5f" % t.to_f   #=> "1270968744.77658"
t.to_i              #=> 1270968744

Note that IEEE 754 double is not accurate enough to represent the exact number of nanoseconds since the Epoch.

Returns:



3544
3545
3546
3547
3548
3549
3550
3551
 
# File 'time.c', line 3544

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

    GetTimeval(time, tobj);
    return rb_Float(rb_time_unmagnify_to_float(tobj->timew));
}

#to_i ⇒ Integer #tv_sec ⇒ Integer

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

t = Time.now
"%10.5f" % t.to_f   #=> "1270968656.89607"
t.to_i              #=> 1270968656

Overloads:



3520
3521
3522
3523
3524
3525
3526
3527
 
# File 'time.c', line 3520

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

    GetTimeval(time, tobj);
    return w2v(wdiv(tobj->timew, WINT2FIXWV(TIME_SCALE)));
}

#to_r ⇒ Object

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

t = Time.now
t.to_r            #=> (1270968792716287611/1000000000)

This methods is intended to be used to get an accurate value representing the nanoseconds since the Epoch. You can use this method to convert time to another Epoch.



3568
3569
3570
3571
3572
3573
3574
3575
3576
3577
3578
3579
3580
 
# File 'time.c', line 3568

static VALUE
time_to_r(VALUE time)
{
    struct time_object *tobj;
    VALUE v;

    GetTimeval(time, tobj);
    v = rb_time_unmagnify_to_rational(tobj->timew);
    if (!RB_TYPE_P(v, T_RATIONAL)) {
        v = rb_Rational1(v);
    }
    return v;
}

#to_s ⇒ String

Returns a string representing time. Equivalent to calling #strftime with the appropriate format string.

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

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

Returns:



4078
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088
 
# File 'time.c', line 4078

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

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj))
        return strftimev("%Y-%m-%d %H:%M:%S UTC", time, rb_usascii_encoding());
    else
        return strftimev("%Y-%m-%d %H:%M:%S %z", time, rb_usascii_encoding());
}

#tuesday? ⇒ Boolean

Returns true if time represents Tuesday.

t = Time.local(1991, 2, 19)      #=> 1991-02-19 00:00:00 -0600
t.tuesday?                       #=> true

Returns:

  • (Boolean) 


4613
4614
4615
4616
4617
 
# File 'time.c', line 4613

static VALUE
time_tuesday(VALUE time)
{
    wday_p(2);
}

#nsec ⇒ Integer #tv_nsec ⇒ Integer

Returns 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 digits of #to_f and #nsec are different because IEEE 754 double is not accurate enough to represent the exact number of nanoseconds since the Epoch.

The more accurate value is returned by #nsec.

Overloads:



3625
3626
3627
3628
3629
3630
3631
3632
 
# File 'time.c', line 3625

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

    GetTimeval(time, tobj);
    return rb_to_int(w2v(wmulquoll(wmod(tobj->timew, WINT2WV(TIME_SCALE)), 1000000000, TIME_SCALE)));
}

#to_i ⇒ Integer #tv_sec ⇒ Integer

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

t = Time.now
"%10.5f" % t.to_f   #=> "1270968656.89607"
t.to_i              #=> 1270968656

Overloads:



3520
3521
3522
3523
3524
3525
3526
3527
 
# File 'time.c', line 3520

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

    GetTimeval(time, tobj);
    return w2v(wdiv(tobj->timew, WINT2FIXWV(TIME_SCALE)));
}

#usec ⇒ Integer #tv_usec ⇒ Integer

Returns 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

Overloads:



3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
 
# File 'time.c', line 3594

static VALUE
time_usec(VALUE time)
{
    struct time_object *tobj;
    wideval_t w, q, r;

    GetTimeval(time, tobj);

    w = wmod(tobj->timew, WINT2WV(TIME_SCALE));
    wmuldivmod(w, WINT2FIXWV(1000000), WINT2FIXWV(TIME_SCALE), &q, &r);
    return rb_to_int(w2v(q));
}

#usec ⇒ Integer #tv_usec ⇒ Integer

Returns 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

Overloads:



3594
3595
3596
3597
3598
3599
3600
3601
3602
3603
3604
3605
 
# File 'time.c', line 3594

static VALUE
time_usec(VALUE time)
{
    struct time_object *tobj;
    wideval_t w, q, r;

    GetTimeval(time, tobj);

    w = wmod(tobj->timew, WINT2WV(TIME_SCALE));
    wmuldivmod(w, WINT2FIXWV(1000000), WINT2FIXWV(TIME_SCALE), &q, &r);
    return rb_to_int(w2v(q));
}

#gmtime ⇒ Time #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

Overloads:



3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
 
# File 'time.c', line 3898

static VALUE
time_gmtime(VALUE time)
{
    struct time_object *tobj;
    struct vtm vtm;

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj)) {
  if (tobj->tm_got)
      return time;
    }
    else {
  time_modify(time);
    }

    vtm.zone = rb_fstring_lit("UTC");
    GMTIMEW(tobj->timew, &vtm);
    tobj->vtm = vtm;

    tobj->tm_got = 1;
    TZMODE_SET_UTC(tobj);
    return time;
}

#utc? ⇒ Boolean #gmt? ⇒ Boolean

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

Overloads:

  • #utc? ⇒ Boolean

    Returns:

    • (Boolean)
  • #gmt? ⇒ Boolean

    Returns:

    • (Boolean) 


3745
3746
3747
3748
3749
3750
3751
3752
3753
 
# File 'time.c', line 3745

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

    GetTimeval(time, tobj);
    if (TZMODE_UTC_P(tobj)) return Qtrue;
    return Qfalse;
}

#gmt_offset ⇒ Integer #gmtoff ⇒ Integer #utc_offset ⇒ Integer

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

Overloads:



4790
4791
4792
4793
4794
4795
4796
4797
4798
4799
4800
4801
4802
4803
4804
 
# File 'time.c', line 4790

VALUE
rb_time_utc_offset(VALUE time)
{
    struct time_object *tobj;

    GetTimeval(time, tobj);

    if (TZMODE_UTC_P(tobj)) {
  return INT2FIX(0);
    }
    else {
  MAKE_TM(time, tobj);
  return tobj->vtm.utc_offset;
    }
}

#wday ⇒ Integer

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

Returns:



4554
4555
4556
4557
4558
4559
4560
4561
4562
 
# File 'time.c', line 4554

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX((int)tobj->vtm.wday);
}

#wednesday? ⇒ Boolean

Returns true if time represents Wednesday.

t = Time.local(1993, 2, 24)      #=> 1993-02-24 00:00:00 -0600
t.wednesday?                     #=> true

Returns:

  • (Boolean) 


4629
4630
4631
4632
4633
 
# File 'time.c', line 4629

static VALUE
time_wednesday(VALUE time)
{
    wday_p(3);
}

#yday ⇒ Integer

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

t = Time.now   #=> 2007-11-19 08:32:31 -0600
t.yday         #=> 323

Returns:



4693
4694
4695
4696
4697
4698
4699
4700
4701
 
# File 'time.c', line 4693

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return INT2FIX(tobj->vtm.yday);
}

#year ⇒ Integer

Returns the year for time (including the century).

t = Time.now   #=> 2007-11-19 08:27:51 -0600
t.year         #=> 2007

Returns:



4526
4527
4528
4529
4530
4531
4532
4533
4534
 
# File 'time.c', line 4526

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

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);
    return tobj->vtm.year;
}

#zone ⇒ String

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"

Returns:



4754
4755
4756
4757
4758
4759
4760
4761
4762
4763
4764
4765
4766
4767
4768
4769
4770
4771
4772
4773
 
# File 'time.c', line 4754

static VALUE
time_zone(VALUE time)
{
    struct time_object *tobj;
    VALUE zone;

    GetTimeval(time, tobj);
    MAKE_TM(time, tobj);

    if (TZMODE_UTC_P(tobj)) {
  return rb_usascii_str_new_cstr("UTC");
    }
    zone = tobj->vtm.zone;
    if (NIL_P(zone))
        return Qnil;

    if (RB_TYPE_P(zone, T_STRING))
        zone = rb_str_dup(zone);
    return zone;
}