Class: DateTime

Relationships & Source Files
Super Chains via Extension / Inclusion / Inheritance
Class Chain: self, `::Date`
Instance Chain: self, `::Date`, Comparable
Inherits:	Date `::Object` Date DateTime
Defined in:	ext/date/date_core.c

Overview

A subclass of ::Date that easily handles date, hour, minute, second, and offset.

DateTime class is considered deprecated. Use Time class.

DateTime does not consider any leap seconds, does not track any summer time rules.

A DateTime object is created with .new, .jd, .ordinal, .commercial, .parse, .strptime, .now, Time#to_datetime, etc.

require 'date'

DateTime.new(2001,2,3,4,5,6)
                    #=> #<DateTime: 2001-02-03T04:05:06+00:00 ...>

The last element of day, hour, minute, or second can be a fractional number. The fractional number’s precision is assumed at most nanosecond.

DateTime.new(2001,2,3.5)
                    #=> #<DateTime: 2001-02-03T12:00:00+00:00 ...>

An optional argument, the offset, indicates the difference between the local time and UTC. For example, Rational(3,24) represents ahead of 3 hours of UTC, Rational(-5,24) represents behind of 5 hours of UTC. The offset should be -1 to +1, and its precision is assumed at most second. The default value is zero (equals to UTC).

DateTime.new(2001,2,3,4,5,6,Rational(3,24))
                    #=> #<DateTime: 2001-02-03T04:05:06+03:00 ...>

The offset also accepts string form:

DateTime.new(2001,2,3,4,5,6,'+03:00')
                    #=> #<DateTime: 2001-02-03T04:05:06+03:00 ...>

An optional argument, the day of calendar reform (start), denotes a Julian day number, which should be 2298874 to 2426355 or negative/positive infinity. The default value is Date::ITALY (2299161=1582-10-15).

A DateTime object has various methods. See each reference.

d = DateTime.parse('3rd Feb 2001 04:05:06+03:30')
                    #=> #<DateTime: 2001-02-03T04:05:06+03:30 ...>
d.hour              #=> 4
d.min               #=> 5
d.sec               #=> 6
d.offset            #=> (7/48)
d.zone              #=> "+03:30"
d += Rational('1.5')
                    #=> #<DateTime: 2001-02-04%16:05:06+03:30 ...>
d = d.new_offset('+09:00')
                    #=> #<DateTime: 2001-02-04%21:35:06+09:00 ...>
d.strftime('%I:%M:%S %p')
                    #=> "09:35:06 PM"
d > DateTime.new(1999)
                    #=> true

When should you use DateTime and when should you use Time?

It’s a common misconception that William Shakespeare and Miguel de Cervantes died on the same day in history - so much so that UNESCO named April 23 as World Book Day because of this fact. However, because England hadn’t yet adopted the Gregorian Calendar Reform (and wouldn’t until 1752) their deaths are actually 10 days apart. Since Ruby’s ::Time class implements a proleptic Gregorian calendar and has no concept of calendar reform there’s no way to express this with ::Time objects. This is where DateTime steps in:

shakespeare = DateTime.iso8601('1616-04-23', Date::ENGLAND)
 #=> Tue, 23 Apr 1616 00:00:00 +0000
cervantes = DateTime.iso8601('1616-04-23', Date::ITALY)
 #=> Sat, 23 Apr 1616 00:00:00 +0000

Already you can see something is weird - the days of the week are different. Taking this further:

cervantes == shakespeare
 #=> false
(shakespeare - cervantes).to_i
 #=> 10

This shows that in fact they died 10 days apart (in reality 11 days since Cervantes died a day earlier but was buried on the 23rd). We can see the actual date of Shakespeare’s death by using the #gregorian method to convert it:

shakespeare.gregorian
 #=> Tue, 03 May 1616 00:00:00 +0000

So there’s an argument that all the celebrations that take place on the 23rd April in Stratford-upon-Avon are actually the wrong date since England is now using the Gregorian calendar. You can see why when we transition across the reform date boundary:

# start off with the anniversary of Shakespeare's birth in 1751
shakespeare = DateTime.iso8601('1751-04-23', Date::ENGLAND)
 #=> Tue, 23 Apr 1751 00:00:00 +0000

# add 366 days since 1752 is a leap year and April 23 is after February 29
shakespeare + 366
 #=> Thu, 23 Apr 1752 00:00:00 +0000

# add another 365 days to take us to the anniversary in 1753
shakespeare + 366 + 365
 #=> Fri, 04 May 1753 00:00:00 +0000

As you can see, if we’re accurately tracking the number of solar years since Shakespeare’s birthday then the correct anniversary date would be the 4th May and not the 23rd April.

So when should you use DateTime in Ruby and when should you use Time? Almost certainly you’ll want to use ::Time since your app is probably dealing with current dates and times. However, if you need to deal with dates and times in a historical context you’ll want to use DateTime to avoid making the same mistakes as UNESCO. If you also have to deal with timezones then best of luck - just bear in mind that you’ll probably be dealing with local solar times, since it wasn’t until the 19th century that the introduction of the railways necessitated the need for Standard Time and eventually timezones.

Constant Summary

`::Date` - Inherited

ABBR_DAYNAMES, ABBR_MONTHNAMES, DAYNAMES, ENGLAND, GREGORIAN, ITALY, JULIAN, MONTHNAMES, VERSION

Class Method Summary

._strptime(string[, format='%FT%T%z']) ⇒ Hash

Parses the given representation of date and time with the given template, and returns a hash of parsed elements.
.civil(*args)

Alias for .new.
.commercial([cwyear=-4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) ⇒ DateTime

Creates a DateTime object denoting the given week date.
.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY]) ⇒ DateTime

Creates a new DateTime object by parsing from a string according to some RFC 2616 format.
.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

Creates a new DateTime object by parsing from a string according to some typical ISO 8601 formats.
.jd([jd=0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) ⇒ DateTime

Creates a DateTime object denoting the given chronological Julian day number.
.jisx0301(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

Creates a new DateTime object by parsing from a string according to some typical JIS X 0301 formats.
.new(*args) (also: .civil) constructor

Same as new.
.now([start = Date::ITALY]) ⇒ DateTime

Creates a DateTime object denoting the present time.
.ordinal([year=-4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) ⇒ DateTime

Creates a DateTime object denoting the given ordinal date.
.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ DateTime

Parses the given representation of date and time, and creates a DateTime object.
.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ DateTime

Alias for .rfc822.
.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

Creates a new DateTime object by parsing from a string according to some typical RFC 3339 formats.
.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ DateTime (also: .rfc2822)

Creates a new DateTime object by parsing from a string according to some typical RFC 2822 formats.
.strptime([string='-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) ⇒ DateTime

Parses the given representation of date and time with the given template, and creates a DateTime object.
.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

Creates a new DateTime object by parsing from a string according to some typical XML Schema formats.
.nth_kday(*args) Internal use only
.weeknum(*args) Internal use only

`::Date` - Inherited

._httpdate	Returns a hash of values parsed from `string`, which should be a valid `HTTP date format`:
._iso8601	Returns a hash of values parsed from `string`, which should contain an `ISO 8601 formatted date`:
._jisx0301	Returns a hash of values parsed from `string`, which should be a valid `JIS X 0301 date format`:
._parse	Note: This method recognizes many forms in `string`, but it is not a validator.
._rfc2822	Alias for Date._rfc822.
._rfc3339	Returns a hash of values parsed from `string`, which should be a valid `RFC 3339 format`:
._rfc822	Returns a hash of values parsed from `string`, which should be a valid `RFC 2822 date format`:
._strptime	Returns a hash of values parsed from `string` according to the given `format`:
._xmlschema	Returns a hash of values parsed from `string`, which should be a valid XML date format:
.civil	Same as Date.new.
.commercial	Returns a new Date object constructed from the arguments.
.gregorian_leap?	Alias for Date.leap?.
.httpdate	Returns a new Date object with values parsed from `string`, which should be a valid `HTTP date format`:
.iso8601	Returns a new Date object with values parsed from `string`, which should contain an `ISO 8601 formatted date`:
.jd	Returns a new Date object formed from the arguments:
.jisx0301	Returns a new Date object with values parsed from `string`, which should be a valid `JIS X 0301 format`:
.julian_leap?	Returns `true` if the given year is a leap year in the proleptic Julian calendar, `false` otherwise:
.leap?	Returns `true` if the given year is a leap year in the proleptic Gregorian calendar, `false` otherwise:
.new	Returns a new Date object constructed from the given arguments:
.ordinal	Returns a new Date object formed fom the arguments.
.parse	Note: This method recognizes many forms in `string`, but it is not a validator.
.rfc2822	Alias for Date.rfc822.
.rfc3339	Returns a new Date object with values parsed from `string`, which should be a valid `RFC 3339 format`:
.rfc822	Returns a new Date object with values parsed from `string`, which should be a valid `RFC 2822 date format`:
.strptime	Returns a new Date object with values parsed from `string`, according to the given `format`:
.today	Returns a new Date object constructed from the present date:
.valid_civil?	Alias for Date.valid_date?.
.valid_commercial?	Returns `true` if the arguments define a valid commercial date, `false` otherwise:
.valid_date?	Returns `true` if the arguments define a valid ordinal date, `false` otherwise:
.valid_jd?	Implemented for compatibility; returns `true` unless .jd is invalid (i.e., not a Numeric).
.valid_ordinal?	Returns `true` if the arguments define a valid ordinal date, `false` otherwise:
.xmlschema	Returns a new Date object with values parsed from `string`, which should be a valid XML date format:
._load, .new!, .nth_kday, .test_all, .test_civil, .test_commercial, .test_nth_kday, .test_ordinal, .test_unit_conv, .test_weeknum, .weeknum

Instance Attribute Summary

`::Date` - Inherited

#friday?	Returns `true` if `self` is a Friday, `false` otherwise.
#gregorian	Equivalent to Date#new_start with argument Date::GREGORIAN.
#gregorian?	Returns `true` if the date is on or after the date of calendar reform, `false` otherwise:
#infinite?	Returns `false`
#julian	Equivalent to Date#new_start with argument Date::JULIAN.
#julian?	Returns `true` if the date is before the date of calendar reform, `false` otherwise:
#leap?	Returns `true` if the year is a leap year, `false` otherwise:
#monday?	Returns `true` if `self` is a Monday, `false` otherwise.
#saturday?	Returns `true` if `self` is a Saturday, `false` otherwise.
#sunday?	Returns `true` if `self` is a Sunday, `false` otherwise.
#thursday?	Returns `true` if `self` is a Thursday, `false` otherwise.
#tuesday?	Returns `true` if `self` is a Tuesday, `false` otherwise.
#wednesday?	Returns `true` if `self` is a Wednesday, `false` otherwise.

Instance Method Summary

#deconstruct_keys(array_of_names_or_nil) ⇒ Hash

Returns a hash of the name/value pairs, to use in pattern matching.
#hour ⇒ Integer

Returns the hour in range (0..23):
#iso8601([n = 0]) ⇒ String (also: #xmlschema)

This method is equivalent to strftime(‘%FT%T%:z’).
#jisx0301([n = 0]) ⇒ String

Returns a string in a JIS X 0301 format.
#min ⇒ Integer (also: #minute)

Returns the minute in range (0..59):
#minute ⇒ Integer

Alias for #min.
#new_offset([offset = 0]) ⇒ date

Duplicates self and resets its offset.
#offset ⇒ Rational

Returns the offset.
#rfc3339([n = 0]) ⇒ String

This method is equivalent to strftime(‘%FT%T%:z’).
#sec ⇒ Integer (also: #second)

Returns the second in range (0..59):
#sec_fraction ⇒ Rational (also: #second_fraction)

Returns the fractional part of the second in range (Rational(0, 1)…Rational(1, 1)):
#second ⇒ Integer

Alias for #sec.
#second_fraction ⇒ Rational

Alias for #sec_fraction.
#strftime(format = '%FT%T%:z') ⇒ String

Returns a string representation of self, formatted according the given +format:
#to_date ⇒ date

Returns a ::Date object which denotes self.
#to_datetime ⇒ self

Returns self.
#to_s ⇒ String

Returns a string in an ISO 8601 format.
#to_time ⇒ Time

Returns a ::Time object which denotes self.
#xmlschema([n = 0]) ⇒ String

Alias for #iso8601.
#zone ⇒ String

Returns the timezone.

`::Date` - Inherited

#+	Returns a date object pointing `other` days after self.
#-	If the other is a date object, returns a Rational whose value is the difference between the two dates in days.
#<<	Returns a new Date object representing the date `n` months earlier; `n` should be a numeric:
#<=>	Compares `self` and `other`, returning:
#===	Returns `true` if `self` and `other` represent the same date, `false` if not, `nil` if the two are not comparable.
#>>	Returns a new Date object representing the date `n` months later; `n` should be a numeric:
#ajd	Returns the astronomical Julian day number.
#amjd	Returns the astronomical modified Julian day number.
#asctime	Alias for Date#ctime.
#ctime	Equivalent to #strftime with argument `'%a %b %e %T %Y'` (or its `shorthand form` `'%c'`):
#cwday	Returns the commercial-date weekday index for `self` (see Date.commercial); 1 is Monday:
#cweek	Returns commercial-date week index for `self` (see Date.commercial):
#cwyear	Returns commercial-date year for `self` (see Date.commercial):
#day	Returns the day of the month in range (1..31):
#day_fraction	Returns the fractional part of the day in range (Rational(0, 1)…Rational(1, 1)):
#deconstruct_keys	Returns a hash of the name/value pairs, to use in pattern matching.
#downto	Equivalent to `#step` with arguments #min and `-1`.
#england	Equivalent to Date#new_start with argument Date::ENGLAND.
#httpdate	Equivalent to #strftime with argument `'%a, %d %b %Y %T GMT'`; see `Formats for Dates and Times`:
#inspect	Returns a string representation of `self`:
#iso8601	Equivalent to #strftime with argument `'%Y-%m-%d'` (or its `shorthand form` `'%F'`);.
#italy	Equivalent to Date#new_start with argument Date::ITALY.
#jd	Returns the Julian day number.
#jisx0301	Returns a string representation of the date in `self` in JIS X 0301 format.
#ld	Returns the Lilian day number, which is the number of days since the beginning of the Gregorian calendar, October 15, 1582.
#mday	Alias for Date#day.
#mjd	Returns the modified Julian day number.
#mon	Returns the month in range (1..12):
#month	Alias for Date#mon.
#new_start	Returns a copy of `self` with the given `start` value:
#next	Returns a new Date object representing the following day:
#next_day	Equivalent to Date#+ with argument `n`.
#next_month	Equivalent to `#>>` with argument `n`.
#next_year	Equivalent to `#>>` with argument `n * 12`.
#prev_day	Equivalent to Date#- with argument `n`.
#prev_month	Equivalent to `#<<` with argument `n`.
#prev_year	Equivalent to `#<<` with argument `n * 12`.
#rfc2822	Alias for Date#rfc822.
#rfc3339	Equivalent to #strftime with argument `'%FT%T%:z'`; see `Formats for Dates and Times`:
#rfc822	Equivalent to #strftime with argument `'%a, %-d %b %Y %T %z'`; see `Formats for Dates and Times`:
#start	Returns the Julian start date for calendar reform; if not an infinity, the returned value is suitable for passing to Date#jd:
#step	Calls the block with specified dates; returns `self`.
#strftime	Returns a string representation of the date in `self`, formatted according the given `format`:
#succ	Alias for Date#next.
#to_date	Returns `self`.
#to_datetime	Returns a `DateTime` whose value is the same as `self`:
#to_s	Returns a string representation of the date in `self` in `ISO 8601 extended date format` (`'%Y-%m-%d'`):
#to_time	Returns a new `::Time` object with the same value as `self`; if `self` is a Julian date, derives its Gregorian date for conversion to the Time object:
#upto	Equivalent to `#step` with arguments `max` and `1`.
#wday	Returns the day of week in range (0..6); Sunday is 0:
#xmlschema	Alias for Date#iso8601.
#yday	Returns the day of the year, in range (1..366):
#year	Returns the year:
#min,
#minute	Alias for Date#min.
#sec	Alias for Date#min.
#second	Alias for Date#min.
#eql?, #fill, #hash, #initialize_copy, #inspect_raw, #marshal_dump, #marshal_dump_old, #marshal_load, #nth_kday?,
#hour	Alias for Date#min.
#wnum0, #wnum1

Constructor Details

.new(*args) Also known as: .civil

Same as new.

[ GitHub ]

# File 'ext/date/date_core.c', line 7797


static VALUE
datetime_s_civil(int argc, VALUE *argv, VALUE klass)
{
    return datetime_initialize(argc, argv, d_lite_s_alloc_complex(klass));
}

Class Method Details

._strptime(string[, format='%FT%T%z']) ⇒ `Hash`

Parses the given representation of date and time with the given template, and returns a hash of parsed elements. _strptime does not support specification of flags and width unlike strftime.

.civil(*args)

Alias for .new.

.commercial([cwyear=-4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) ⇒ `DateTime`

Creates a DateTime object denoting the given week date.

DateTime.commercial(2001) #=> #<DateTime: 2001-01-01T00:00:00+00:00 ...>
DateTime.commercial(2002) #=> #<DateTime: 2001-12-31T00:00:00+00:00 ...>
DateTime.commercial(2001,5,6,4,5,6,'+7')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

[ GitHub ]

# File 'ext/date/date_core.c', line 7912


static VALUE
datetime_s_commercial(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int w, d, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "08", &vy, &vw, &vd, &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    w = 1;
    d = 1;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 8:
	val2sg(vsg, sg);
      case 7:
	val2off(vof, rof);
      case 6:
        check_numeric(vs, "second");
	num2int_with_frac(s, positive_inf);
      case 5:
        check_numeric(vmin, "minute");
	num2int_with_frac(min, 5);
      case 4:
        check_numeric(vh, "hour");
	num2int_with_frac(h, 4);
      case 3:
        check_numeric(vd, "cwday");
	num2int_with_frac(d, 3);
      case 2:
        check_numeric(vw, "cweek");
	w = NUM2INT(vw);
      case 1:
        check_numeric(vy, "year");
	y = vy;
    }

    {
	VALUE nth;
	int ry, rw, rd, rh, rmin, rs, rjd, rjd2, ns;

	if (!valid_commercial_p(y, w, d, sg,
				&nth, &ry,
				&rw, &rd, &rjd,
				&ns))
	    rb_raise(eDateError, "invalid date");
	if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
	    rb_raise(eDateError, "invalid date");
	canon24oc();

	rjd2 = jd_local_to_utc(rjd,
			       time_to_df(rh, rmin, rs),
			       rof);

	ret = d_complex_new_internal(klass,
				     nth, rjd2,
				     0, INT2FIX(0),
				     rof, sg,
				     0, 0, 0,
				     rh, rmin, rs,
				     HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY]) ⇒ `DateTime`

Creates a new DateTime object by parsing from a string according to some RFC 2616 format.

DateTime.httpdate('Sat, 03 Feb 2001 04:05:06 GMT')
                          #=> #<DateTime: 2001-02-03T04:05:06+00:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8623


static VALUE
datetime_s_httpdate(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg, opt;

    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME_HTTPDATE);
      case 1:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 1;
        VALUE argv2[2], hash;
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__httpdate(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

Creates a new DateTime object by parsing from a string according to some typical ISO 8601 formats.

DateTime.iso8601('2001-02-03T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.iso8601('20010203T040506+0700')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.iso8601('2001-W05-6T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8466


static VALUE
datetime_s_iso8601(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg, opt;

    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME);
      case 1:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 1;
        VALUE argv2[2], hash;
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__iso8601(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

.jd([jd=0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) ⇒ `DateTime`

Creates a DateTime object denoting the given chronological Julian day number.

DateTime.jd(2451944)      #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
DateTime.jd(2451945)      #=> #<DateTime: 2001-02-04T00:00:00+00:00 ...>
DateTime.jd(Rational('0.5'))
                          #=> #<DateTime: -4712-01-01T12:00:00+00:00 ...>

[ GitHub ]

# File 'ext/date/date_core.c', line 7654


static VALUE
datetime_s_jd(int argc, VALUE *argv, VALUE klass)
{
    VALUE vjd, vh, vmin, vs, vof, vsg, jd, fr, fr2, ret;
    int h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "06", &vjd, &vh, &vmin, &vs, &vof, &vsg);

    jd = INT2FIX(0);

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 6:
	val2sg(vsg, sg);
      case 5:
	val2off(vof, rof);
      case 4:
        check_numeric(vs, "second");
	num2int_with_frac(s, positive_inf);
      case 3:
        check_numeric(vmin, "minute");
	num2int_with_frac(min, 3);
      case 2:
        check_numeric(vh, "hour");
	num2int_with_frac(h, 2);
      case 1:
        check_numeric(vjd, "jd");
	num2num_with_frac(jd, 1);
    }

    {
	VALUE nth;
	int rh, rmin, rs, rjd, rjd2;

	if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
	    rb_raise(eDateError, "invalid date");
	canon24oc();

	decode_jd(jd, &nth, &rjd);
	rjd2 = jd_local_to_utc(rjd,
			       time_to_df(rh, rmin, rs),
			       rof);

	ret = d_complex_new_internal(klass,
				     nth, rjd2,
				     0, INT2FIX(0),
				     rof, sg,
				     0, 0, 0,
				     rh, rmin, rs,
				     HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

.jisx0301(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

Creates a new DateTime object by parsing from a string according to some typical JIS X 0301 formats.

DateTime.jisx0301('H13.02.03T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

For no-era year, legacy format, Heisei is assumed.

DateTime.jisx0301('13.02.03T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8667


static VALUE
datetime_s_jisx0301(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg, opt;

    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME);
      case 1:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 1;
        VALUE argv2[2], hash;
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__jisx0301(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

.now([start = Date::ITALY]) ⇒ `DateTime`

Creates a DateTime object denoting the present time.

DateTime.now              #=> #<DateTime: 2011-06-11T21:20:44+09:00 ...>

[ GitHub ]

# File 'ext/date/date_core.c', line 8134


static VALUE
datetime_s_now(int argc, VALUE *argv, VALUE klass)
{
    VALUE vsg, nth, ret;
    double sg;
#ifdef HAVE_CLOCK_GETTIME
    struct timespec ts;
#else
    struct timeval tv;
#endif
    time_t sec;
    struct tm tm;
    long sf, of;
    int y, ry, m, d, h, min, s;

    rb_scan_args(argc, argv, "01", &vsg);

    if (argc < 1)
	sg = DEFAULT_SG;
    else
	sg = NUM2DBL(vsg);

#ifdef HAVE_CLOCK_GETTIME
    if (clock_gettime(CLOCK_REALTIME, &ts) == -1)
	rb_sys_fail("clock_gettime");
    sec = ts.tv_sec;
#else
    if (gettimeofday(&tv, NULL) == -1)
	rb_sys_fail("gettimeofday");
    sec = tv.tv_sec;
#endif
    tzset();
    if (!localtime_r(&sec, &tm))
	rb_sys_fail("localtime");

    y = tm.tm_year + 1900;
    m = tm.tm_mon + 1;
    d = tm.tm_mday;
    h = tm.tm_hour;
    min = tm.tm_min;
    s = tm.tm_sec;
    if (s == 60)
	s = 59;
#ifdef HAVE_STRUCT_TM_TM_GMTOFF
    of = tm.tm_gmtoff;
#elif defined(HAVE_TIMEZONE)
#if defined(HAVE_ALTZONE) && !defined(_AIX)
    of = (long)-((tm.tm_isdst > 0) ? altzone : timezone);
#else
    of = (long)-timezone;
    if (tm.tm_isdst) {
	time_t sec2;

	tm.tm_isdst = 0;
	sec2 = mktime(&tm);
	of += (long)difftime(sec2, sec);
    }
#endif
#elif defined(HAVE_TIMEGM)
    {
	time_t sec2;

	sec2 = timegm(&tm);
	of = (long)difftime(sec2, sec);
    }
#else
    {
	struct tm tm2;
	time_t sec2;

	if (!gmtime_r(&sec, &tm2))
	    rb_sys_fail("gmtime");
	tm2.tm_isdst = tm.tm_isdst;
	sec2 = mktime(&tm2);
	of = (long)difftime(sec, sec2);
    }
#endif
#ifdef HAVE_CLOCK_GETTIME
    sf = ts.tv_nsec;
#else
    sf = tv.tv_usec * 1000;
#endif

    if (of < -DAY_IN_SECONDS || of > DAY_IN_SECONDS) {
	of = 0;
	rb_warning("invalid offset is ignored");
    }

    decode_year(INT2FIX(y), -1, &nth, &ry);

    ret = d_complex_new_internal(klass,
				 nth, 0,
				 0, LONG2NUM(sf),
				 (int)of, GREGORIAN,
				 ry, m, d,
				 h, min, s,
				 HAVE_CIVIL | HAVE_TIME);
    {
	get_d1(ret);
	set_sg(dat, sg);
    }
    return ret;
}

.nth_kday(*args)

This method is for internal use only.

[ GitHub ]

# File 'ext/date/date_core.c', line 8056


static VALUE
datetime_s_nth_kday(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vn, vk, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int m, n, k, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "09", &vy, &vm, &vn, &vk,
		 &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    m = 1;
    n = 1;
    k = 1;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 9:
	val2sg(vsg, sg);
      case 8:
	val2off(vof, rof);
      case 7:
	num2int_with_frac(s, positive_inf);
      case 6:
	num2int_with_frac(min, 6);
      case 5:
	num2int_with_frac(h, 5);
      case 4:
	num2int_with_frac(k, 4);
      case 3:
	n = NUM2INT(vn);
      case 2:
	m = NUM2INT(vm);
      case 1:
	y = vy;
    }

    {
	VALUE nth;
	int ry, rm, rn, rk, rh, rmin, rs, rjd, rjd2, ns;

	if (!valid_nth_kday_p(y, m, n, k, sg,
			      &nth, &ry,
			      &rm, &rn, &rk, &rjd,
			      &ns))
	    rb_raise(eDateError, "invalid date");
	if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
	    rb_raise(eDateError, "invalid date");
	canon24oc();

	rjd2 = jd_local_to_utc(rjd,
			       time_to_df(rh, rmin, rs),
			       rof);
	ret = d_complex_new_internal(klass,
				     nth, rjd2,
				     0, INT2FIX(0),
				     rof, sg,
				     0, 0, 0,
				     rh, rmin, rs,
				     HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

.ordinal([year=-4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) ⇒ `DateTime`

Creates a DateTime object denoting the given ordinal date.

DateTime.ordinal(2001,34) #=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
DateTime.ordinal(2001,34,4,5,6,'+7')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.ordinal(2001,-332,-20,-55,-54,'+7')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

[ GitHub ]

# File 'ext/date/date_core.c', line 7726


static VALUE
datetime_s_ordinal(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vd, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int d, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "07", &vy, &vd, &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    d = 1;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 7:
	val2sg(vsg, sg);
      case 6:
	val2off(vof, rof);
      case 5:
        check_numeric(vs, "second");
	num2int_with_frac(s, positive_inf);
      case 4:
        check_numeric(vmin, "minute");
	num2int_with_frac(min, 4);
      case 3:
        check_numeric(vh, "hour");
	num2int_with_frac(h, 3);
      case 2:
        check_numeric(vd, "yday");
	num2int_with_frac(d, 2);
      case 1:
        check_numeric(vy, "year");
	y = vy;
    }

    {
	VALUE nth;
	int ry, rd, rh, rmin, rs, rjd, rjd2, ns;

	if (!valid_ordinal_p(y, d, sg,
			     &nth, &ry,
			     &rd, &rjd,
			     &ns))
	    rb_raise(eDateError, "invalid date");
	if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
	    rb_raise(eDateError, "invalid date");
	canon24oc();

	rjd2 = jd_local_to_utc(rjd,
			       time_to_df(rh, rmin, rs),
			       rof);

	ret = d_complex_new_internal(klass,
				     nth, rjd2,
				     0, INT2FIX(0),
				     rof, sg,
				     0, 0, 0,
				     rh, rmin, rs,
				     HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ `DateTime`

Parses the given representation of date and time, and creates a DateTime object.

This method does not function as a validator. If the input string does not match valid formats strictly, you may get a cryptic result. Should consider to use .strptime instead of this method as possible.

If the optional second argument is true and the detected year is in the range “00” to “99”, makes it full.

DateTime.parse('2001-02-03T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.parse('20010203T040506+0700')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.parse('3rd Feb 2001 04:05:06 PM')
                          #=> #<DateTime: 2001-02-03T16:05:06+00:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8420


static VALUE
datetime_s_parse(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, comp, sg, opt;

    argc = rb_scan_args(argc, argv, "03:", &str, &comp, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME);
      case 1:
	comp = Qtrue;
      case 2:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 2;
        VALUE argv2[3], hash;
        argv2[0] = str;
        argv2[1] = comp;
        argv2[2] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__parse(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime` .rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

Alias for .rfc822.

.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

Creates a new DateTime object by parsing from a string according to some typical RFC 3339 formats.

DateTime.rfc3339('2001-02-03T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8505


static VALUE
datetime_s_rfc3339(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg, opt;

    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME);
      case 1:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 1;
        VALUE argv2[2], hash;
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__rfc3339(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime` .rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`
Also known as: .rfc2822

Creates a new DateTime object by parsing from a string according to some typical RFC 2822 formats.

DateTime.rfc2822('Sat, 3 Feb 2001 04:05:06 +0700')
                         #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8584


static VALUE
datetime_s_rfc2822(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg, opt;

    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME_RFC3339);
      case 1:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 1;
        VALUE argv2[2], hash;
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__rfc2822(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

.strptime([string='-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) ⇒ `DateTime`

Parses the given representation of date and time with the given template, and creates a DateTime object. strptime does not support specification of flags and width unlike strftime.

DateTime.strptime('2001-02-03T04:05:06+07:00', '%Y-%m-%dT%H:%M:%S%z')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.strptime('03-02-2001 04:05:06 PM', '%d-%m-%Y %I:%M:%S %p')
                          #=> #<DateTime: 2001-02-03T16:05:06+00:00 ...>
DateTime.strptime('2001-W05-6T04:05:06+07:00', '%G-W%V-%uT%H:%M:%S%z')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.strptime('2001 04 6 04 05 06 +7', '%Y %U %w %H %M %S %z')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.strptime('2001 05 6 04 05 06 +7', '%Y %W %u %H %M %S %z')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>
DateTime.strptime('-1', '%s')
                          #=> #<DateTime: 1969-12-31T23:59:59+00:00 ...>
DateTime.strptime('-1000', '%Q')
                          #=> #<DateTime: 1969-12-31T23:59:59+00:00 ...>
DateTime.strptime('sat3feb014pm+7', '%a%d%b%y%H%p%z')
                          #=> #<DateTime: 2001-02-03T16:00:00+07:00 ...>

.weeknum(*args)

This method is for internal use only.

[ GitHub ]

# File 'ext/date/date_core.c', line 7986


static VALUE
datetime_s_weeknum(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vf, vh, vmin, vs, vof, vsg, y, fr, fr2, ret;
    int w, d, f, h, min, s, rof;
    double sg;

    rb_scan_args(argc, argv, "09", &vy, &vw, &vd, &vf,
		 &vh, &vmin, &vs, &vof, &vsg);

    y = INT2FIX(-4712);
    w = 0;
    d = 1;
    f = 0;

    h = min = s = 0;
    fr2 = INT2FIX(0);
    rof = 0;
    sg = DEFAULT_SG;

    switch (argc) {
      case 9:
	val2sg(vsg, sg);
      case 8:
	val2off(vof, rof);
      case 7:
	num2int_with_frac(s, positive_inf);
      case 6:
	num2int_with_frac(min, 6);
      case 5:
	num2int_with_frac(h, 5);
      case 4:
	f = NUM2INT(vf);
      case 3:
	num2int_with_frac(d, 4);
      case 2:
	w = NUM2INT(vw);
      case 1:
	y = vy;
    }

    {
	VALUE nth;
	int ry, rw, rd, rh, rmin, rs, rjd, rjd2, ns;

	if (!valid_weeknum_p(y, w, d, f, sg,
			     &nth, &ry,
			     &rw, &rd, &rjd,
			     &ns))
	    rb_raise(eDateError, "invalid date");
	if (!c_valid_time_p(h, min, s, &rh, &rmin, &rs))
	    rb_raise(eDateError, "invalid date");
	canon24oc();

	rjd2 = jd_local_to_utc(rjd,
			       time_to_df(rh, rmin, rs),
			       rof);
	ret = d_complex_new_internal(klass,
				     nth, rjd2,
				     0, INT2FIX(0),
				     rof, sg,
				     0, 0, 0,
				     rh, rmin, rs,
				     HAVE_JD | HAVE_TIME);
    }
    add_frac();
    return ret;
}

.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

Creates a new DateTime object by parsing from a string according to some typical XML Schema formats.

DateTime.xmlschema('2001-02-03T04:05:06+07:00')
                          #=> #<DateTime: 2001-02-03T04:05:06+07:00 ...>

Raise an ArgumentError when the string length is longer than limit. You can stop this check by passing limit: nil, but note that it may take a long time to parse.

[ GitHub ]

# File 'ext/date/date_core.c', line 8544


static VALUE
datetime_s_xmlschema(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, sg, opt;

    argc = rb_scan_args(argc, argv, "02:", &str, &sg, &opt);

    switch (argc) {
      case 0:
	str = rb_str_new2(JULIAN_EPOCH_DATETIME);
      case 1:
	sg = INT2FIX(DEFAULT_SG);
    }

    {
        int argc2 = 1;
        VALUE argv2[2], hash;
        argv2[0] = str;
        argv2[1] = opt;
        if (!NIL_P(opt)) argc2++;
	hash = date_s__xmlschema(argc2, argv2, klass);
	return dt_new_by_frags(klass, hash, sg);
    }
}

Instance Method Details

#deconstruct_keys(array_of_names_or_nil) ⇒ `Hash`

Returns a hash of the name/value pairs, to use in pattern matching. Possible keys are: :year, :month, :day, :wday, :yday, :hour, :min, :sec, :sec_fraction, :zone.

Possible usages:

dt = DateTime.new(2022, 10, 5, 13, 30)

if d in wday: 1..5, hour: 10..18  # uses deconstruct_keys underneath
  puts "Working time"
end
#=> prints "Working time"

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

Note that deconstruction by pattern can also be combined with class check:

if d in DateTime(wday: 1..5, hour: 10..18, day: ..7)
  puts "Working time, first week of the month"
end

[ GitHub ]

# File 'ext/date/date_core.c', line 8842


static VALUE
dt_lite_deconstruct_keys(VALUE self, VALUE keys)
{
    return deconstruct_keys(self, keys, /* is_datetime=true */ 1);
}

#hour ⇒ `Integer`

Returns the hour in range (0..23):

DateTime.new(2001, 2, 3, 4, 5, 6).hour # => 4

[ GitHub ]

# File 'ext/date/date_core.c', line 5582


static VALUE
d_lite_hour(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_hour(dat));
}

#iso8601([n = 0]) ⇒ `String` #xmlschema([n = 0]) ⇒ `String`
Also known as: #xmlschema

This method is equivalent to strftime(‘%FT%T%:z’). The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').iso8601(9)
                          #=> "2001-02-03T04:05:06.123456789+07:00"

[ GitHub ]

# File 'ext/date/date_core.c', line 8755


static VALUE
dt_lite_iso8601(int argc, VALUE *argv, VALUE self)
{
    long n = 0;

    rb_check_arity(argc, 0, 1);
    if (argc >= 1)
	n = NUM2LONG(argv[0]);

    return rb_str_append(strftimev("%Y-%m-%d", self, set_tmx),
			 iso8601_timediv(self, n));
}

#jisx0301([n = 0]) ⇒ `String`

Returns a string in a JIS X 0301 format. The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').jisx0301(9)
                          #=> "H13.02.03T04:05:06.123456789+07:00"

[ GitHub ]

# File 'ext/date/date_core.c', line 8794


static VALUE
dt_lite_jisx0301(int argc, VALUE *argv, VALUE self)
{
    long n = 0;

    rb_check_arity(argc, 0, 1);
    if (argc >= 1)
	n = NUM2LONG(argv[0]);

    return rb_str_append(d_lite_jisx0301(self),
			 iso8601_timediv(self, n));
}

#min ⇒ `Integer` Also known as: #minute

Returns the minute in range (0..59):

DateTime.new(2001, 2, 3, 4, 5, 6).min # => 5

[ GitHub ]

# File 'ext/date/date_core.c', line 5598


static VALUE
d_lite_min(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_min(dat));
}

#min ⇒ `Integer` #minute ⇒ `Integer`

Alias for #min.

#new_offset([offset = 0]) ⇒ `date`

Duplicates self and resets its offset.

d = DateTime.new(2001,2,3,4,5,6,'-02:00')
                          #=> #<DateTime: 2001-02-03T04:05:06-02:00 ...>
d.new_offset('+09:00')    #=> #<DateTime: 2001-02-03T15:05:06+09:00 ...>

[ GitHub ]

# File 'ext/date/date_core.c', line 5921


static VALUE
d_lite_new_offset(int argc, VALUE *argv, VALUE self)
{
    VALUE vof;
    int rof;

    rb_scan_args(argc, argv, "01", &vof);

    rof = 0;
    if (argc >= 1)
	val2off(vof, rof);

    return dup_obj_with_new_offset(self, rof);
}

#offset ⇒ `Rational`

Returns the offset.

DateTime.parse('04pm+0730').offset        #=> (5/16)

[ GitHub ]

# File 'ext/date/date_core.c', line 5646


static VALUE
d_lite_offset(VALUE self)
{
    get_d1(self);
    return m_of_in_day(dat);
}

#rfc3339([n = 0]) ⇒ `String`

This method is equivalent to strftime(‘%FT%T%:z’). The optional argument n is the number of digits for fractional seconds.

DateTime.parse('2001-02-03T04:05:06.123456789+07:00').rfc3339(9)
                          #=> "2001-02-03T04:05:06.123456789+07:00"

[ GitHub ]

# File 'ext/date/date_core.c', line 8778


static VALUE
dt_lite_rfc3339(int argc, VALUE *argv, VALUE self)
{
    return dt_lite_iso8601(argc, argv, self);
}

#sec ⇒ `Integer` Also known as: #second

Returns the second in range (0..59):

DateTime.new(2001, 2, 3, 4, 5, 6).sec # => 6

[ GitHub ]

# File 'ext/date/date_core.c', line 5614


static VALUE
d_lite_sec(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_sec(dat));
}

#sec_fraction ⇒ `Rational` Also known as: #second_fraction

Returns the fractional part of the second in range (Rational(0, 1)…Rational(1, 1)):

DateTime.new(2001, 2, 3, 4, 5, 6.5).sec_fraction # => (1/2)

[ GitHub ]

# File 'ext/date/date_core.c', line 5631


static VALUE
d_lite_sec_fraction(VALUE self)
{
    get_d1(self);
    return m_sf_in_sec(dat);
}

#sec ⇒ `Integer` #second ⇒ `Integer`

Alias for #sec.

#sec_fraction ⇒ `Rational` #second_fraction ⇒ `Rational`

Alias for #sec_fraction.

#strftime(format = '%FT%T%:z') ⇒ `String`

Returns a string representation of self, formatted according the given +format:

DateTime.now.strftime # => "2022-07-01T11:03:19-05:00"

For other formats, see Formats for Dates and Times:

[ GitHub ]

# File 'ext/date/date_core.c', line 8721


static VALUE
dt_lite_strftime(int argc, VALUE *argv, VALUE self)
{
    return date_strftime_internal(argc, argv, self,
				  "%Y-%m-%dT%H:%M:%S%:z", set_tmx);
}

#to_date ⇒ `date`

Returns a ::Date object which denotes self.

[ GitHub ]

# File 'ext/date/date_core.c', line 9069


static VALUE
datetime_to_date(VALUE self)
{
    get_d1a(self);

    if (simple_dat_p(adat)) {
	VALUE new = d_lite_s_alloc_simple(cDate);
	{
	    get_d1b(new);
	    bdat->s = adat->s;
	    bdat->s.jd = m_local_jd(adat);
	    return new;
	}
    }
    else {
	VALUE new = d_lite_s_alloc_simple(cDate);
	{
	    get_d1b(new);
	    copy_complex_to_simple(new, &bdat->s, &adat->c);
	    bdat->s.jd = m_local_jd(adat);
	    bdat->s.flags &= ~(HAVE_DF | HAVE_TIME | COMPLEX_DAT);
	    return new;
	}
    }
}

#to_datetime ⇒ `self`

Returns self.

[ GitHub ]

# File 'ext/date/date_core.c', line 9101


static VALUE
datetime_to_datetime(VALUE self)
{
    return self;
}

#to_s ⇒ `String`

Returns a string in an ISO 8601 format. (This method doesn’t use the expanded representations.)

DateTime.new(2001,2,3,4,5,6,'-7').to_s
                         #=> "2001-02-03T04:05:06-07:00"

[ GitHub ]

# File 'ext/date/date_core.c', line 8702


static VALUE
dt_lite_to_s(VALUE self)
{
    return strftimev("%Y-%m-%dT%H:%M:%S%:z", self, set_tmx);
}

#to_time ⇒ Time

Returns a ::Time object which denotes self.

[ GitHub ]

# File 'ext/date/date_core.c', line 9032


static VALUE
datetime_to_time(VALUE self)
{
    get_d1(self);

    if (m_julian_p(dat)) {
	VALUE g = d_lite_gregorian(self);
	get_d1a(g);
	dat = adat;
	self = g;
    }

    {
	VALUE t;

	t = rb_funcall(rb_cTime,
		   rb_intern("new"),
                   7,
		   m_real_year(dat),
		   INT2FIX(m_mon(dat)),
		   INT2FIX(m_mday(dat)),
		   INT2FIX(m_hour(dat)),
		   INT2FIX(m_min(dat)),
		   f_add(INT2FIX(m_sec(dat)),
			 m_sf_in_sec(dat)),
		   INT2FIX(m_of(dat)));
	RB_GC_GUARD(self); /* may be the converted gregorian */
	return t;
    }
}

#iso8601([n = 0]) ⇒ `String` #xmlschema([n = 0]) ⇒ `String`

Alias for #iso8601.

#zone ⇒ `String`

Returns the timezone.

DateTime.parse('04pm+0730').zone          #=> "+07:30"

[ GitHub ]

# File 'ext/date/date_core.c', line 5661


static VALUE
d_lite_zone(VALUE self)
{
    get_d1(self);
    return m_zone(dat);
}

Class: DateTime

Overview

When should you use DateTime and when should you use Time?

Constant Summary

::Date - Inherited

Class Method Summary

::Date - Inherited

Instance Attribute Summary

::Date - Inherited

Instance Method Summary

::Date - Inherited

Constructor Details

.new(*args) Also known as: .civil

Class Method Details

._strptime(string[, format='%FT%T%z']) ⇒ Hash

.civil(*args)

.commercial([cwyear=-4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) ⇒ DateTime

.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY]) ⇒ DateTime

.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

.jd([jd=0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) ⇒ DateTime

.jisx0301(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

.now([start = Date::ITALY]) ⇒ DateTime

.nth_kday(*args)

.ordinal([year=-4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) ⇒ DateTime

.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ DateTime

.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ DateTime .rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ DateTime

.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ DateTime .rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ DateTime Also known as: .rfc2822

.strptime([string='-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) ⇒ DateTime

.weeknum(*args)

.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ DateTime

Instance Method Details

#deconstruct_keys(array_of_names_or_nil) ⇒ Hash

#hour ⇒ Integer

#iso8601([n = 0]) ⇒ String #xmlschema([n = 0]) ⇒ String Also known as: #xmlschema

#jisx0301([n = 0]) ⇒ String

#min ⇒ Integer Also known as: #minute

#min ⇒ Integer #minute ⇒ Integer

#new_offset([offset = 0]) ⇒ date

#offset ⇒ Rational

#rfc3339([n = 0]) ⇒ String

#sec ⇒ Integer Also known as: #second

#sec_fraction ⇒ Rational Also known as: #second_fraction

#sec ⇒ Integer #second ⇒ Integer

#sec_fraction ⇒ Rational #second_fraction ⇒ Rational

#strftime(format = '%FT%T%:z') ⇒ String

#to_date ⇒ date

#to_datetime ⇒ self

#to_s ⇒ String

#to_time ⇒ Time

#iso8601([n = 0]) ⇒ String #xmlschema([n = 0]) ⇒ String

#zone ⇒ String

`::Date` - Inherited

`::Date` - Inherited

`::Date` - Inherited

`::Date` - Inherited

._strptime(string[, format='%FT%T%z']) ⇒ `Hash`

.commercial([cwyear=-4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) ⇒ `DateTime`

.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY]) ⇒ `DateTime`

.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

.jd([jd=0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) ⇒ `DateTime`

.jisx0301(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

.now([start = Date::ITALY]) ⇒ `DateTime`

.ordinal([year=-4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) ⇒ `DateTime`

.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]], limit: 128) ⇒ `DateTime`

.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime` .rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime` .rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`
Also known as: .rfc2822

.strptime([string='-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) ⇒ `DateTime`

.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) ⇒ `DateTime`

#deconstruct_keys(array_of_names_or_nil) ⇒ `Hash`

#hour ⇒ `Integer`

#iso8601([n = 0]) ⇒ `String` #xmlschema([n = 0]) ⇒ `String`
Also known as: #xmlschema

#jisx0301([n = 0]) ⇒ `String`

#min ⇒ `Integer` Also known as: #minute

#min ⇒ `Integer` #minute ⇒ `Integer`

#new_offset([offset = 0]) ⇒ `date`

#offset ⇒ `Rational`

#rfc3339([n = 0]) ⇒ `String`

#sec ⇒ `Integer` Also known as: #second

#sec_fraction ⇒ `Rational` Also known as: #second_fraction

#sec ⇒ `Integer` #second ⇒ `Integer`

#sec_fraction ⇒ `Rational` #second_fraction ⇒ `Rational`

#strftime(format = '%FT%T%:z') ⇒ `String`

#to_date ⇒ `date`

#to_datetime ⇒ `self`

#to_s ⇒ `String`

#iso8601([n = 0]) ⇒ `String` #xmlschema([n = 0]) ⇒ `String`

#zone ⇒ `String`