Class: Date
Relationships & Source Files | |
Extension / Inclusion / Inheritance Descendants | |
Subclasses:
|
|
Super Chains via Extension / Inclusion / Inheritance | |
Instance Chain:
self,
Comparable
|
|
Inherits: | Object |
Defined in: | ext/date/date_core.c, ext/date/lib/date.rb |
Overview
date and datetime class - Tadayoshi Funaba 1998-2011
'date' provides two classes Date
and ::Time.
Terms and definitions
Some terms and definitions are based on ISO 8601 and JIS X 0301.
calendar date
The calendar date is a particular day of a calendar year, identified by its ordinal number within a calendar month within that year.
In those classes, this is so-called “civil”.
ordinal date
The ordinal date is a particular day of a calendar year identified by its ordinal number within the year.
In those classes, this is so-called “ordinal”.
week date
The week date is a date identified by calendar week and day numbers.
The calendar week is a seven day period within a calendar year, starting on a Monday and identified by its ordinal number within the year; the first calendar week of the year is the one that includes the first Thursday of that year. In the Gregorian calendar, this is equivalent to the week which includes January 4.
In those classes, this so-called “commercial”.
julian day number
The Julian day number is in elapsed days since noon (Greenwich mean time) on January 1, 4713 BCE (in the Julian calendar).
In this document, the astronomical Julian day number is same as the original Julian day number. And the chronological Julian day number is a variation of the Julian day number. Its days begin at midnight on local time.
In this document, when the term “Julian day number” simply appears, it just refers to “chronological Julian day number”, not the original.
In those classes, those are so-called “ajd” and “jd”.
modified julian day number
The modified Julian day number is in elapsed days since midnight (Coordinated universal time) on November 17, 1858 CE (in the Gregorian calendar).
In this document, the astronomical modified Julian day number is same as the original modified Julian day number. And the chronological modified Julian day number is a variation of the modified Julian day number. Its days begin at midnight on local time.
In this document, when the term “modified Julian day number” simply appears, it just refers to “chronological modified Julian day number”, not the original.
In those classes, this is so-called “mjd”.
Date
A subclass of ::Object that includes Comparable module and easily handles date.
Date
object is created with .new, .jd, .ordinal, .commercial, .parse, .strptime, .today, Time#to_date or etc.
require 'date'
Date.new(2001,2,3)
#=> #<Date: 2001-02-03 ...>
Date.jd(2451944)
#=> #<Date: 2001-02-03 ...>
Date.ordinal(2001,34)
#=> #<Date: 2001-02-03 ...>
Date.commercial(2001,5,6)
#=> #<Date: 2001-02-03 ...>
Date.parse('2001-02-03')
#=> #<Date: 2001-02-03 ...>
Date.strptime('03-02-2001', '%d-%m-%Y')
#=> #<Date: 2001-02-03 ...>
Time.new(2001,2,3).to_date
#=> #<Date: 2001-02-03 ...>
All date objects are immutable; hence cannot modify themselves.
The concept of this date object can be represented as a tuple of the day count, the offset and the day of calendar reform.
The day count denotes the absolute position of a temporal dimension. The offset is relative adjustment, which determines decoded local time with the day count. The day of calendar reform denotes the start day of the new style. The old style of the West is the Julian calendar which was adopted by Caesar. The new style is the Gregorian calendar, which is the current civil calendar of many countries.
The day count is virtually the astronomical Julian day number. The offset in this class is usually zero, and cannot be specified directly.
An optional argument the day of calendar reform (start) as a Julian day number, which should be 2298874 to 2426355 or -/+oo. The default value is ITALY (2299161=1582-10-15). See also sample/cal.rb.
$ ruby sample/cal.rb -c it 10 1582
October 1582
S M Tu W Th F S
1 2 3 4 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
$ ruby sample/cal.rb -c gb 9 1752
September 1752
S M Tu W Th F S
1 2 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
Date
object has various methods. See each reference.
d = Date.parse('3rd Feb 2001')
#=> #<Date: 2001-02-03 ...>
d.year #=> 2001
d.mon #=> 2
d.mday #=> 3
d.wday #=> 6
d += 1 #=> #<Date: 2001-02-04 ...>
d.strftime('%a %d %b %Y') #=> "Sun 04 Feb 2001"
Constant Summary
-
ABBR_DAYNAMES =
An array of strings of abbreviated day names in English. The first is “Sun”.
mk_ary_of_str(7, abbr_daynames)
-
ABBR_MONTHNAMES =
An array of strings of abbreviated month names in English. The first element is nil.
mk_ary_of_str(13, abbr_monthnames)
-
DAYNAMES =
An array of strings of the full names of days of the week in English. The first is “Sunday”.
mk_ary_of_str(7, daynames)
-
ENGLAND =
The Julian day number of the day of calendar reform for England and her colonies.
INT2FIX(ENGLAND)
-
GREGORIAN =
The Julian day number of the day of calendar reform for the proleptic Gregorian calendar
DBL2NUM(GREGORIAN)
-
ITALY =
The Julian day number of the day of calendar reform for Italy and some catholic countries.
INT2FIX(ITALY)
-
JULIAN =
The Julian day number of the day of calendar reform for the proleptic Julian calendar
DBL2NUM(JULIAN)
-
MONTHNAMES =
An array of strings of full month names in English. The first element is nil.
mk_ary_of_str(13, monthnames)
Class Method Summary
-
._httpdate(string) ⇒ Hash
Returns a hash of parsed elements.
-
._iso8601(string) ⇒ Hash
Returns a hash of parsed elements.
-
._jisx0301(string) ⇒ Hash
Returns a hash of parsed elements.
-
._parse(string[, comp=true]) ⇒ Hash
Parses the given representation of date and time, and returns a hash of parsed elements.
-
._rfc2822(string) ⇒ Hash
Alias for ._rfc822.
-
._rfc3339(string) ⇒ Hash
Returns a hash of parsed elements.
-
._rfc822(string) ⇒ Hash
(also: ._rfc2822)
Returns a hash of parsed elements.
-
._strptime(string[, format='%F']) ⇒ Hash
Parses the given representation of date and time with the given template, and returns a hash of parsed elements.
-
._xmlschema(string) ⇒ Hash
Returns a hash of parsed elements.
-
.civil([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
Alias for .new.
-
.commercial([cwyear=-4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ Date
Creates a date object denoting the given week date.
-
.gregorian_leap?(year) ⇒ Boolean
Alias for .leap?.
-
.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=ITALY]) ⇒ Date
Creates a new
Date
object by parsing from a string according to some RFC 2616 format. -
.iso8601(string='-4712-01-01'[, start=ITALY]) ⇒ Date
Creates a new
Date
object by parsing from a string according to some typical ISO 8601 formats. -
.jd([jd=0[, start=Date::ITALY]]) ⇒ Date
Creates a date object denoting the given chronological Julian day number.
-
.jisx0301(string='-4712-01-01'[, start=ITALY]) ⇒ Date
Creates a new
Date
object by parsing from a string according to some typical JIS X 0301 formats. -
.julian_leap?(year) ⇒ Boolean
Returns true if the given year is a leap year of the proleptic Julian calendar.
-
.leap?(year) ⇒ Boolean
(also: .gregorian_leap?)
Returns true if the given year is a leap year of the proleptic Gregorian calendar.
-
.new([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
(also: .civil)
constructor
Creates a date object denoting the given calendar date.
-
.ordinal([year=-4712[, yday=1[, start=Date::ITALY]]]) ⇒ Date
Creates a date object denoting the given ordinal date.
-
.parse(string='-4712-01-01'[, comp=true[, start=ITALY]]) ⇒ Date
Parses the given representation of date and time, and creates a date object.
-
.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
Alias for .rfc822.
-
.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) ⇒ Date
Creates a new
Date
object by parsing from a string according to some typical RFC 3339 formats. -
.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
(also: .rfc2822)
Creates a new
Date
object by parsing from a string according to some typical RFC 2822 formats. -
.strptime([string='-4712-01-01'[, format='%F'[, start=ITALY]]]) ⇒ Date
Parses the given representation of date and time with the given template, and creates a date object.
-
.today([start = Date::ITALY]) ⇒ Date
Date
.today #=> #<Date: 2011-06-11 ..>. -
.valid_civil?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
Alias for .valid_date?.
-
.valid_commercial?(cwyear, cweek, cwday[, start=Date::ITALY]) ⇒ Boolean
Returns true if the given week date is valid, and false if not.
-
.valid_date?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
(also: .valid_civil?)
Returns true if the given calendar date is valid, and false if not.
-
.valid_jd?(jd[, start=Date::ITALY]) ⇒ Boolean
Just returns true.
-
.valid_ordinal?(year, yday[, start=Date::ITALY]) ⇒ Boolean
Returns true if the given ordinal date is valid, and false if not.
-
.xmlschema(string='-4712-01-01'[, start=ITALY]) ⇒ Date
Creates a new
Date
object by parsing from a string according to some typical XML Schema formats.
Instance Attribute Summary
-
#friday? ⇒ Boolean
readonly
Returns true if the date is Friday.
-
#gregorian ⇒ Date
readonly
This method is equivalent to new_start(Date::GREGORIAN).
-
#gregorian? ⇒ Boolean
readonly
Retunrs true if the date is on or after the day of calendar reform.
-
#julian ⇒ Date
readonly
This method is equivalent to new_start(Date::JULIAN).
-
#julian? ⇒ Boolean
readonly
Retruns true if the date is before the day of calendar reform.
-
#leap? ⇒ Boolean
readonly
Returns true if the year is a leap year.
-
#monday? ⇒ Boolean
readonly
Returns true if the date is Monday.
-
#saturday? ⇒ Boolean
readonly
Returns true if the date is Saturday.
-
#sunday? ⇒ Boolean
readonly
Returns true if the date is Sunday.
-
#thursday? ⇒ Boolean
readonly
Returns true if the date is Thursday.
-
#tuesday? ⇒ Boolean
readonly
Returns true if the date is Tuesday.
-
#wednesday? ⇒ Boolean
readonly
Returns true if the date is Wednesday.
Instance Method Summary
-
#+(other) ⇒ Date
Returns a date object pointing other days after self.
-
#-(other) ⇒ Date, Rational
Returns the difference between the two dates if the other is a date object.
-
#<<(n) ⇒ Date
Returns a date object pointing n months before self.
-
#<=>(other) ⇒ 1, ...
Compares the two dates and returns -1, zero, 1 or nil.
-
#===(other) ⇒ Boolean
Returns true if they are the same day.
-
#>>(n) ⇒ Date
Returns a date object pointing n months after self.
-
#ajd ⇒ Rational
Returns the astronomical Julian day number.
-
#amjd ⇒ Rational
Returns the astronomical modified Julian day number.
-
#asctime ⇒ String
Alias for #ctime.
-
#ctime ⇒ String
(also: #asctime)
Returns a string in asctime(3) format (but without “n0” at the end).
-
#cwday ⇒ Fixnum
Returns the day of calendar week (1-7, Monday is 1).
-
#cweek ⇒ Fixnum
Returns the calendar week number (1-53).
-
#cwyear ⇒ Integer
Returns the calendar week based year.
-
#day ⇒ Fixnum
(also: #mday)
Returns the day of the month (1-31).
-
#day_fraction ⇒ Rational
Returns the fractional part of the day.
-
#downto(min) ⇒ Enumerator
This method is equivalent to step(min, -1){|date| …}.
-
#england ⇒ Date
This method is equivalent to new_start(Date::ENGLAND).
-
#httpdate ⇒ String
This method is equivalent to strftime('%a, %d %b %Y %T GMT').
-
#inspect ⇒ String
Returns the value as a string for inspection.
-
#iso8601 ⇒ String
(also: #xmlschema)
This method is equivalent to strftime('%F').
-
#italy ⇒ Date
This method is equivalent to new_start(Date::ITALY).
-
#jd ⇒ Integer
Returns the Julian day number.
-
#jisx0301 ⇒ String
Returns a string in a JIS X 0301 format.
-
#ld ⇒ Integer
Returns the Lilian day number.
-
#mday ⇒ Fixnum
Alias for #day.
-
#mjd ⇒ Integer
Returns the modified Julian day number.
-
#mon ⇒ Fixnum
(also: #month)
Returns the month (1-12).
-
#month ⇒ Fixnum
Alias for #mon.
-
#new_start([start = Date::ITALY]) ⇒ Date
Duplicates self and resets its the day of calendar reform.
-
#next ⇒ Date
(also: #succ)
Returns a date object denoting the following day.
-
#next_day([n = 1]) ⇒ Date
This method is equivalent to d + n.
-
#next_month([n = 1]) ⇒ Date
This method is equivalent to d >> n.
-
#next_year([n = 1]) ⇒ Date
This method is equivalent to d >> (n * 12).
-
#prev_day([n = 1]) ⇒ Date
This method is equivalent to d - n.
-
#prev_month([n = 1]) ⇒ Date
This method is equivalent to d << n.
-
#prev_year([n = 1]) ⇒ Date
This method is equivalent to d << (n * 12).
-
#rfc2822 ⇒ String
Alias for #rfc822.
-
#rfc3339 ⇒ String
This method is equivalent to strftime('%FT%T%:z').
-
#rfc822 ⇒ String
(also: #rfc2822)
This method is equivalent to strftime('%a, %-d %b %Y %T %z').
-
#start ⇒ Float
Returns the Julian day number denoting the day of calendar reform.
-
#step(limit[, step=1]) ⇒ Enumerator
Iterates evaluation of the given block, which takes a date object.
-
#strftime([format = '%F']) ⇒ String
Formats date according to the directives in the given format string.
-
#succ ⇒ Date
Alias for #next.
-
#to_date ⇒ self
Returns self;.
-
#to_datetime ⇒ Date
Returns a ::Time object which denotes self.
-
#to_s ⇒ String
Returns a string in an ISO 8601 format (This method doesn't use the expanded representations).
-
#to_time ⇒ Time
Returns a ::Time object which denotes self.
-
#upto(max) ⇒ Enumerator
This method is equivalent to step(max, 1){|date| …}.
-
#wday ⇒ Fixnum
Returns the day of week (0-6, Sunday is zero).
-
#xmlschema ⇒ String
Alias for #iso8601.
-
#yday ⇒ Fixnum
Returns the day of the year (1-366).
-
#year ⇒ Integer
Returns the year.
-
#hour ⇒ Fixnum
private
Returns the hour (0-23).
-
#min ⇒ Fixnum
(also: #minute)
private
Returns the minute (0-59).
-
#minute ⇒ Fixnum
private
Alias for #min.
-
#new_offset([offset = 0]) ⇒ Date
private
Duplicates self and resets its offset.
-
#offset ⇒ Rational
private
Returns the offset.
-
#sec ⇒ Fixnum
(also: #second)
private
Returns the second (0-59).
-
#sec_fraction ⇒ Rational
(also: #second_fraction)
private
Returns the fractional part of the second.
-
#second ⇒ Fixnum
private
Alias for #sec.
-
#second_fraction ⇒ Rational
private
Alias for #sec_fraction.
-
#zone ⇒ String
private
Returns the timezone.
Constructor Details
.civil([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
.new([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
Also known as: .civil
Date
.new([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
Creates a date object denoting the given calendar date.
In this class, BCE years are counted astronomically. Thus, the year before the year 1 is the year zero, and the year preceding the year zero is the year -1. The month and the day of month should be a negative or a positive number (as a relative month/day from the end of year/month when negative). They should not be zero.
The last argument should be a Julian day number which denotes the day of calendar reform. ITALY (2299161=1582-10-15), ENGLAND (2361222=1752-09-14), GREGORIAN (the proleptic Gregorian calendar) and JULIAN (the proleptic Julian calendar) can be specified as a day of calendar reform.
Date.new(2001) #=> #<Date: 2001-01-01 ...>
Date.new(2001,2,3) #=> #<Date: 2001-02-03 ...>
Date.new(2001,2,-1) #=> #<Date: 2001-02-28 ...>
See also jd.
Class Method Details
._httpdate(string) ⇒ Hash
Returns a hash of parsed elements.
._iso8601(string) ⇒ Hash
Returns a hash of parsed elements.
._jisx0301(string) ⇒ Hash
Returns a hash of parsed elements.
._parse(string[, comp=true]) ⇒ Hash
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}
._rfc2822(string) ⇒ Hash
._rfc822(string) ⇒ Hash
Hash
._rfc822(string) ⇒ Hash
Alias for ._rfc822.
._rfc3339(string) ⇒ Hash
Returns a hash of parsed elements.
._rfc2822(string) ⇒ Hash
._rfc822(string) ⇒ Hash
Also known as: ._rfc2822
Hash
._rfc822(string) ⇒ Hash
Returns a hash of parsed elements.
._strptime(string[, format='%F']) ⇒ 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.
Date._strptime('2001-02-03', '%Y-%m-%d')
#=> {:year=>2001, :mon=>2, :mday=>3}
See also strptime(3) and strftime.
._xmlschema(string) ⇒ Hash
Returns a hash of parsed elements.
.civil([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
.new([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
Date
.new([year=-4712[, month=1[, mday=1[, start=Date::ITALY]]]]) ⇒ Date
Alias for .new.
.commercial([cwyear=-4712[, cweek=1[, cwday=1[, start=Date::ITALY]]]]) ⇒ Date
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.
.gregorian_leap?(year) ⇒ Boolean
.leap?(year) ⇒ Boolean
Boolean
.leap?(year) ⇒ Boolean
Alias for .leap?.
.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=ITALY]) ⇒ Date
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 ...>
.iso8601(string='-4712-01-01'[, start=ITALY]) ⇒ Date
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 ...>
.jd([jd=0[, start=Date::ITALY]]) ⇒ Date
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.
.jisx0301(string='-4712-01-01'[, start=ITALY]) ⇒ Date
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 ...>
.julian_leap?(year) ⇒ Boolean
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
.gregorian_leap?(year) ⇒ Boolean
.leap?(year) ⇒ Boolean
Also known as: .gregorian_leap?
Boolean
.leap?(year) ⇒ Boolean
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
.ordinal([year=-4712[, yday=1[, start=Date::ITALY]]]) ⇒ Date
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.
.parse(string='-4712-01-01'[, comp=true[, start=ITALY]]) ⇒ Date
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 ...>
.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
Date
.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
Alias for .rfc822.
.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=ITALY]) ⇒ Date
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 ...>
.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
Also known as: .rfc2822
Date
.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=ITALY]) ⇒ Date
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 ...>
.strptime([string='-4712-01-01'[, format='%F'[, start=ITALY]]]) ⇒ Date
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.
.today([start = Date::ITALY]) ⇒ Date
Date
.today #=> #<Date: 2011-06-11 ..>
Creates a date object denoting the present day.
.valid_civil?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
.valid_date?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
Boolean
.valid_date?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
Alias for .valid_date?.
.valid_commercial?(cwyear, cweek, cwday[, start=Date::ITALY]) ⇒ Boolean
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.
.valid_civil?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
.valid_date?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
Also known as: .valid_civil?
Boolean
.valid_date?(year, month, mday[, start=Date::ITALY]) ⇒ Boolean
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.
.valid_jd?(jd[, start=Date::ITALY]) ⇒ Boolean
Just returns true. It's nonsense, but is for symmetry.
Date.valid_jd?(2451944) #=> true
See also jd.
.valid_ordinal?(year, yday[, start=Date::ITALY]) ⇒ Boolean
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.
.xmlschema(string='-4712-01-01'[, start=ITALY]) ⇒ Date
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 ...>
Instance Attribute Details
#friday? ⇒ Boolean
(readonly)
Returns true if the date is Friday.
#gregorian ⇒ Date
(readonly)
This method is equivalent to new_start(Date::GREGORIAN).
#gregorian? ⇒ Boolean
(readonly)
#julian ⇒ Date
(readonly)
This method is equivalent to new_start(Date::JULIAN).
#julian? ⇒ Boolean
(readonly)
#leap? ⇒ Boolean
(readonly)
#monday? ⇒ Boolean
(readonly)
Returns true if the date is Monday.
#saturday? ⇒ Boolean
(readonly)
Returns true if the date is Saturday.
#sunday? ⇒ Boolean
(readonly)
Returns true if the date is Sunday.
#thursday? ⇒ Boolean
(readonly)
Returns true if the date is Thursday.
#tuesday? ⇒ Boolean
(readonly)
Returns true if the date is Tuesday.
#wednesday? ⇒ Boolean
(readonly)
Returns true if the date is Wednesday.
Instance Method Details
#+(other) ⇒ Date
Returns a date object pointing other days after self. The other should be a numeric value. If the other is flonum, assumes its precision is at most nanosecond.
Date.new(2001,2,3) + 1 #=> #<Date: 2001-02-04 ...>
DateTime.new(2001,2,3) + Rational(1,2)
#=> #<DateTime: 2001-02-03T12:00:00+00:00 ...>
DateTime.new(2001,2,3) + Rational(-1,2)
#=> #<DateTime: 2001-02-02T12:00:00+00:00 ...>
DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd
#=> #<DateTime: 2001-02-03T00:00:00+00:00 ...>
#-(other) ⇒ Date
, Rational
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)
#<<(n) ⇒ Date
#<=>(other) ⇒ 1
, ...
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.
#===(other) ⇒ Boolean
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
#>>(n) ⇒ Date
#ajd ⇒ Rational
#amjd ⇒ Rational
#asctime ⇒ String
#ctime ⇒ String
String
#ctime ⇒ String
Alias for #ctime.
#asctime ⇒ String
#ctime ⇒ String
Also known as: #asctime
String
#ctime ⇒ String
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).
#cwday ⇒ Fixnum
Returns the day of calendar week (1-7, Monday is 1).
Date.new(2001,2,3).cwday #=> 6
#cweek ⇒ Fixnum
Returns the calendar week number (1-53).
Date.new(2001,2,3).cweek #=> 5
#cwyear ⇒ Integer
#mday ⇒ Fixnum
#day ⇒ Fixnum
Also known as: #mday
Fixnum
#day ⇒ Fixnum
#day_fraction ⇒ Rational
#downto(min) ⇒ Enumerator
#downto(min) {|date| ... } ⇒ self
Enumerator
#downto(min) {|date| ... } ⇒ self
This method is equivalent to step(min, -1){|date| …}.
#england ⇒ Date
This method is equivalent to new_start(Date::ENGLAND).
#hour ⇒ Fixnum
(private)
#httpdate ⇒ String
This method is equivalent to strftime('%a, %d %b %Y %T GMT'). See also RFC 2616.
#inspect ⇒ String
#iso8601 ⇒ String
#xmlschema ⇒ String
Also known as: #xmlschema
String
#xmlschema ⇒ String
This method is equivalent to strftime('%F').
#italy ⇒ Date
This method is equivalent to new_start(Date::ITALY).
#jd ⇒ Integer
#jisx0301 ⇒ String
#ld ⇒ Integer
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
#mday ⇒ Fixnum
#day ⇒ Fixnum
Fixnum
#day ⇒ Fixnum
Alias for #day.
#min ⇒ Fixnum
(private)
#minute ⇒ Fixnum
Also known as: #minute
Fixnum
(private)
#minute ⇒ Fixnum
#min ⇒ Fixnum
(private)
#minute ⇒ Fixnum
Fixnum
(private)
#minute ⇒ Fixnum
Alias for #min.
#mjd ⇒ Integer
#mon ⇒ Fixnum
#month ⇒ Fixnum
Also known as: #month
Fixnum
#month ⇒ Fixnum
Returns the month (1-12).
Date.new(2001,2,3).mon #=> 2
#mon ⇒ Fixnum
#month ⇒ Fixnum
Fixnum
#month ⇒ Fixnum
Alias for #mon.
#new_offset([offset = 0]) ⇒ Date
(private)
#new_start([start = Date::ITALY]) ⇒ Date
#succ ⇒ Date
#next ⇒ Date
Also known as: #succ
Date
#next ⇒ Date
Returns a date object denoting the following day.
#next_day([n = 1]) ⇒ Date
This method is equivalent to d + n.
#next_month([n = 1]) ⇒ Date
This method is equivalent to d >> n
#next_year([n = 1]) ⇒ Date
This method is equivalent to d >> (n * 12)
#offset ⇒ Rational
(private)
#prev_day([n = 1]) ⇒ Date
This method is equivalent to d - n.
#prev_month([n = 1]) ⇒ Date
This method is equivalent to d << n
#prev_year([n = 1]) ⇒ Date
This method is equivalent to d << (n * 12)
#rfc2822 ⇒ String
#rfc822 ⇒ String
String
#rfc822 ⇒ String
Alias for #rfc822.
#rfc3339 ⇒ String
This method is equivalent to strftime('%FT%T%:z').
#rfc2822 ⇒ String
#rfc822 ⇒ String
Also known as: #rfc2822
String
#rfc822 ⇒ String
This method is equivalent to strftime('%a, %-d %b %Y %T %z').
#sec ⇒ Fixnum
(private)
#second ⇒ Fixnum
Also known as: #second
Fixnum
(private)
#second ⇒ Fixnum
#sec_fraction ⇒ Rational
(private)
#second_fraction ⇒ Rational
Also known as: #second_fraction
Rational
(private)
#second_fraction ⇒ Rational
#sec ⇒ Fixnum
(private)
#second ⇒ Fixnum
Fixnum
(private)
#second ⇒ Fixnum
Alias for #sec.
#sec_fraction ⇒ Rational
(private)
#second_fraction ⇒ Rational
Rational
(private)
#second_fraction ⇒ Rational
Alias for #sec_fraction.
#start ⇒ Float
#step(limit[, step=1]) ⇒ Enumerator
#step(limit[, step=1]) {|date| ... } ⇒ self
Enumerator
#step(limit[, step=1]) {|date| ... } ⇒ self
#strftime([format = '%F']) ⇒ String
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.
#succ ⇒ Date
#next ⇒ Date
Date
#next ⇒ Date
Alias for #next.
#to_date ⇒ self
Returns self;
#to_datetime ⇒ Date
Returns a ::Time object which denotes self.
#to_s ⇒ String
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"
#to_time ⇒ Time
Returns a ::Time object which denotes self.
#upto(max) ⇒ Enumerator
#upto(max) {|date| ... } ⇒ self
Enumerator
#upto(max) {|date| ... } ⇒ self
This method is equivalent to step(max, 1){|date| …}.
#wday ⇒ Fixnum
Returns the day of week (0-6, Sunday is zero).
Date.new(2001,2,3).wday #=> 6
#iso8601 ⇒ String
#xmlschema ⇒ String
String
#xmlschema ⇒ String
Alias for #iso8601.
#yday ⇒ Fixnum
Returns the day of the year (1-366).
Date.new(2001,2,3).yday #=> 34