Class: Date

Returns a hash of parsed elements.

Returns a hash of parsed elements.

Parses the given representation of date and time, and returns a hash of parsed elements. This method does not function as a validator.

If the optional second argument is true and the detected year is in the range “00” to “99”, considers the year a 2-digit form and makes it full.

Date._parse('2001-02-03') #=> {:year=>2001, :mon=>2, :mday=>3}

Alias for ._rfc822.

Returns a hash of parsed elements.

Returns a hash of parsed elements.

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.

Date._strptime('2001-02-03', '%Y-%m-%d')
                            #=> {:year=>2001, :mon=>2, :mday=>3}

See also strptime(3) and strftime.

Returns a hash of parsed elements.

Alias for .new.

Creates a date object denoting the given week date.

The week and the day of week should be a negative or a positive number (as a relative week/day from the end of year/week when negative). They should not be zero.

Date.commercial(2001)     #=> #<Date: 2001-01-01 ...>
Date.commercial(2002)     #=> #<Date: 2001-12-31 ...>
Date.commercial(2001,5,6) #=> #<Date: 2001-02-03 ...>

See also jd and new.

Alias for .leap?.

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

Date.httpdate('Sat, 03 Feb 2001 00:00:00 GMT')
                                          #=> #<Date: 2001-02-03 ...>

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

Date.iso8601('2001-02-03')        #=> #<Date: 2001-02-03 ...>
Date.iso8601('20010203')          #=> #<Date: 2001-02-03 ...>
Date.iso8601('2001-W05-6')        #=> #<Date: 2001-02-03 ...>

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

Date.jd(2451944)          #=> #<Date: 2001-02-03 ...>
Date.jd(2451945)          #=> #<Date: 2001-02-04 ...>
Date.jd(0)                #=> #<Date: -4712-01-01 ...>

See also new.

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

Date.jisx0301('H13.02.03')                #=> #<Date: 2001-02-03 ...>

Returns true if the given year is a leap year of the proleptic Julian calendar.

Date.julian_leap?(1900)           #=> true
Date.julian_leap?(1901)           #=> false

Returns true if the given year is a leap year of the proleptic Gregorian calendar.

Date.gregorian_leap?(1900)        #=> false
Date.gregorian_leap?(2000)        #=> true

Creates a date object denoting the given ordinal date.

The day of year should be a negative or a positive number (as a relative day from the end of year when negative). It should not be zero.

Date.ordinal(2001)        #=> #<Date: 2001-01-01 ...>
Date.ordinal(2001,34)     #=> #<Date: 2001-02-03 ...>
Date.ordinal(2001,-1)     #=> #<Date: 2001-12-31 ...>

See also jd and new.

Parses the given representation of date and time, and creates a date object. This method does not function as a validator.

If the optional second argument is true and the detected year is in the range “00” to “99”, considers the year a 2-digit form and makes it full.

Date.parse('2001-02-03')          #=> #<Date: 2001-02-03 ...>
Date.parse('20010203')            #=> #<Date: 2001-02-03 ...>
Date.parse('3rd Feb 2001')        #=> #<Date: 2001-02-03 ...>

Alias for .rfc822.

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

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

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

Date.rfc2822('Sat, 3 Feb 2001 00:00:00 +0000')
                                          #=> #<Date: 2001-02-03 ...>

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

Date.strptime('2001-02-03', '%Y-%m-%d')   #=> #<Date: 2001-02-03 ...>
Date.strptime('03-02-2001', '%d-%m-%Y')   #=> #<Date: 2001-02-03 ...>
Date.strptime('2001-034', '%Y-%j')        #=> #<Date: 2001-02-03 ...>
Date.strptime('2001-W05-6', '%G-W%V-%u')  #=> #<Date: 2001-02-03 ...>
Date.strptime('2001 04 6', '%Y %U %w')    #=> #<Date: 2001-02-03 ...>
Date.strptime('2001 05 6', '%Y %W %u')    #=> #<Date: 2001-02-03 ...>
Date.strptime('sat3feb01', '%a%d%b%y')    #=> #<Date: 2001-02-03 ...>

See also strptime(3) and strftime.

Date.today #=> #<Date: 2011-06-11 ..>

Creates a date object denoting the present day.

Alias for .valid_date?.

Returns true if the given week date is valid, and false if not.

Date.valid_commercial?(2001,5,6)  #=> true
Date.valid_commercial?(2001,5,8)  #=> false

See also jd and commercial.

Returns true if the given calendar date is valid, and false if not.

Date.valid_date?(2001,2,3)        #=> true
Date.valid_date?(2001,2,29)       #=> false

See also jd and civil.

Just returns true. It's nonsense, but is for symmetry.

Date.valid_jd?(2451944)           #=> true

See also jd.

Returns true if the given ordinal date is valid, and false if not.

Date.valid_ordinal?(2001,34)      #=> true
Date.valid_ordinal?(2001,366)     #=> false

See also jd and ordinal.

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

Date.xmlschema('2001-02-03')      #=> #<Date: 2001-02-03 ...>

This method is equivalent to new_start(Date::GREGORIAN).

Retunrs true if the date is on or after the day of calendar reform.

Date.new(1582,10,15).gregorian?          #=> true
(Date.new(1582,10,15) - 1).gregorian?    #=> false

This method is equivalent to new_start(Date::JULIAN).

Retruns true if the date is before the day of calendar reform.

Date.new(1582,10,15).julian?             #=> false
(Date.new(1582,10,15) - 1).julian?       #=> true

Returns true if the year is a leap year.

Date.new(2000).leap?      #=> true
Date.new(2001).leap?      #=> false

Returns true if the date is Monday.

Returns true if the date is Saturday.

Returns true if the date is Sunday.

Returns true if the date is Thursday.

Returns true if the date is Tuesday.

Returns true if the date is Wednesday.

Returns the difference between the two dates if the other is a date object. If the other is a numeric value, returns a date object pointing other days before self. If the other is flonum, assumes its precision is at most nanosecond.

Date.new(2001,2,3) - 1   #=> #<Date: 2001-02-02 ...>
DateTime.new(2001,2,3) - Rational(1,2)
                         #=> #<DateTime: 2001-02-02T12:00:00+00:00 ...>
Date.new(2001,2,3) - Date.new(2001)
                         #=> (33/1)
DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12)
                         #=> (1/2)

Returns a date object pointing n months before self. The n should be a numeric value.

Date.new(2001,2,3) << 1   #=> #<Date: 2001-01-03 ...>
Date.new(2001,1,31) << 11 #=> #<Date: 2000-02-29 ...>
Date.new(2001,2,3) << -1  #=> #<Date: 2001-03-03 ...>

Compares the two dates and returns -1, zero, 1 or nil. The other should be a date object or a numeric value as an astronomical Julian day number.

Date.new(2001,2,3) <=> Date.new(2001,2,4) #=> -1
Date.new(2001,2,3) <=> Date.new(2001,2,3) #=> 0
Date.new(2001,2,3) <=> Date.new(2001,2,2) #=> 1
Date.new(2001,2,3) <=> Object.new         #=> nil
Date.new(2001,2,3) <=> Rational(4903887,2)#=> 0

See also Comparable.

Returns true if they are the same day.

Date.new(2001,2,3) === Date.new(2001,2,3)
                                  #=> true
Date.new(2001,2,3) === Date.new(2001,2,4)
                                  #=> false
DateTime.new(2001,2,3) === DateTime.new(2001,2,3,12)
                                  #=> true
DateTime.new(2001,2,3) === DateTime.new(2001,2,3,0,0,0,'+24:00')
                                  #=> true
DateTime.new(2001,2,3) === DateTime.new(2001,2,4,0,0,0,'+24:00')
                                  #=> false

Returns a date object pointing n months after self. The n should be a numeric value.

Date.new(2001,2,3) >> 1   #=> #<Date: 2001-03-03 ...>
Date.new(2001,1,31) >> 1  #=> #<Date: 2001-02-28 ...>
Date.new(2001,2,3) >> -2  #=> #<Date: 2000-12-03 ...>

Returns the astronomical Julian day number. This is a fractional number, which is not adjusted by the offset.

DateTime.new(2001,2,3,4,5,6,'+7').ajd     #=> (11769328217/4800)
DateTime.new(2001,2,2,14,5,6,'-7').ajd    #=> (11769328217/4800)

Returns the astronomical modified Julian day number. This is a fractional number, which is not adjusted by the offset.

DateTime.new(2001,2,3,4,5,6,'+7').amjd    #=> (249325817/4800)
DateTime.new(2001,2,2,14,5,6,'-7').amjd   #=> (249325817/4800)

Alias for #ctime.

Returns a string in asctime(3) format (but without “n0” at the end). This method is equivalent to strftime('%c').

See also asctime(3) or ctime(3).

Returns the day of calendar week (1-7, Monday is 1).

Date.new(2001,2,3).cwday          #=> 6

Returns the calendar week number (1-53).

Date.new(2001,2,3).cweek          #=> 5

Returns the calendar week based year.

Date.new(2001,2,3).cwyear         #=> 2001
Date.new(2000,1,1).cwyear         #=> 1999

Returns the day of the month (1-31).

Date.new(2001,2,3).mday           #=> 3

Returns the fractional part of the day.

DateTime.new(2001,2,3,12).day_fraction    #=> (1/2)

This method is equivalent to step(min, -1){|date| …}.

This method is equivalent to new_start(Date::ENGLAND).

Returns the hour (0-23).

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

This method is equivalent to strftime('%a, %d %b %Y %T GMT'). See also RFC 2616.

Returns the value as a string for inspection.

Date.new(2001,2,3).inspect
          #=> "#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>"
DateTime.new(2001,2,3,4,5,6,'-7').inspect
          #=> "#<DateTime: 2001-02-03T04:05:06-07:00 ((2451944j,39906s,0n),-25200s,2299161j)>"

This method is equivalent to strftime('%F').

This method is equivalent to new_start(Date::ITALY).

Returns the Julian day number. This is a whole number, which is adjusted by the offset as the local time.

DateTime.new(2001,2,3,4,5,6,'+7').jd      #=> 2451944
DateTime.new(2001,2,3,4,5,6,'-7').jd      #=> 2451944

Returns a string in a JIS X 0301 format.

Date.new(2001,2,3).jisx0301       #=> "H13.02.03"

Returns the Lilian day number. This is a whole number, which is adjusted by the offset as the local time.

Date.new(2001,2,3).ld            #=> 152784

Alias for #day.

Returns the minute (0-59).

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

Alias for #min.

Returns the modified Julian day number. This is a whole number, which is adjusted by the offset as the local time.

DateTime.new(2001,2,3,4,5,6,'+7').mjd     #=> 51943
DateTime.new(2001,2,3,4,5,6,'-7').mjd     #=> 51943

Returns the month (1-12).

Date.new(2001,2,3).mon            #=> 2

Alias for #mon.

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

Duplicates self and resets its the day of calendar reform.

d = Date.new(1582,10,15)
d.new_start(Date::JULIAN)         #=> #<Date: 1582-10-05 ...>

Returns a date object denoting the following day.

This method is equivalent to d + n.

This method is equivalent to d >> n

This method is equivalent to d >> (n * 12)

Returns the offset.

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

This method is equivalent to d - n.

This method is equivalent to d << n

This method is equivalent to d << (n * 12)

Alias for #rfc822.

This method is equivalent to strftime('%FT%T%:z').

This method is equivalent to strftime('%a, %-d %b %Y %T %z').

Returns the second (0-59).

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

Returns the fractional part of the second.

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

Alias for #sec.

Alias for #sec_fraction.

Returns the Julian day number denoting the day of calendar reform.

Date.new(2001,2,3).start                  #=> 2299161.0
Date.new(2001,2,3,Date::GREGORIAN).start  #=> -Infinity

Iterates evaluation of the given block, which takes a date object. The limit should be a date object.

Date.new(2001).step(Date.new(2001,-1,-1)).select{|d| d.sunday?}.size
                          #=> 52

Formats date according to the directives in the given format

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

A directive consists of a percent (%) character,
zero or more flags, an optional minimum field width,
an 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.

The minimum field width specifies the minimum width.

The modifiers are "E", "O", ":", "::" and ":::".
"E" and "O" are ignored.  No effect to result currently.

Format directives:

  Date (Year, Month, Day):
    %Y - Year with century (can be negative, 4 digits at least)
            -0001, 0000, 1995, 2009, 14292, etc.
    %C - year / 100 (round down.  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..59)

    %L - Millisecond of the second (000..999)
    %N - Fractional seconds digits, default is 9 digits (nanosecond)
            %3N  millisecond (3 digits)   %15N femtosecond (15 digits)
            %6N  microsecond (6 digits)   %18N attosecond  (18 digits)
            %9N  nanosecond  (9 digits)   %21N zeptosecond (21 digits)
            %12N picosecond (12 digits)   %24N yoctosecond (24 digits)

  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 - hour, minute and second offset from UTC
                                              (e.g. +09, +09:30, +09:30:30)
    %Z - Equivalent to %:z (e.g. +09:00)

  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 week 1 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 week 1 of YYYY 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 Unix Epoch:
    %s - Number of seconds since 1970-01-01 00:00:00 UTC.
    %Q - Number of milliseconds 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-%Y)
    %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)
    %+ - date(1) (%a %b %e %H:%M:%S %Z %Y)

This method is similar to strftime() function defined in ISO C and POSIX.
Several directives (%a, %A, %b, %B, %c, %p, %r, %x, %X, %E*, %O* and %Z)
are locale dependent in the function.
However this method is locale independent.
So, the result may differ even if a same format string is used in other
systems such as C.
It is good practice to avoid %x and %X because there are corresponding
locale independent representations, %D and %T.

Examples:

  d = DateTime.new(2007,11,19,8,37,48,"-06:00")
                            #=> #<DateTime: 2007-11-19T08:37:48-0600 ...>
  d.strftime("Printed on %m/%d/%Y")   #=> "Printed on 11/19/2007"
  d.strftime("at %I:%M%p")            #=> "at 08:37AM"

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)

See also strftime(3) and strptime.

Alias for #next.

Returns self;

Returns a ::Time object which denotes self.

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

Date.new(2001,2,3).to_s  #=> "2001-02-03"

Returns a ::Time object which denotes self.

This method is equivalent to step(max, 1){|date| …}.

Returns the day of week (0-6, Sunday is zero).

Date.new(2001,2,3).wday           #=> 6

Alias for #iso8601.

Returns the day of the year (1-366).

Date.new(2001,2,3).yday           #=> 34

Returns the year.

Date.new(2001,2,3).year           #=> 2001
(Date.new(1,1,1) - 1).year        #=> 0

Returns the timezone.

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