class Date

Die Klasse Date stellt Methoden zur Speicherung und Manipulation von Kalenderdaten bereit.

Erwägen Sie die Verwendung von class Time anstelle von class Date, wenn

Sie sowohl Daten als auch Zeiten benötigen; Date verarbeitet nur Daten.
Sie nur gregorianische Daten benötigen (und keine julianischen Daten); siehe Julianische und Gregorianische Kalender.

Ein Date-Objekt ist nach der Erstellung unveränderlich und kann nicht geändert werden.

Erstellung eines Datums

Sie können ein Datum für das aktuelle Datum erstellen, indem Sie Date.today verwenden

Date.today # => #<Date: 1999-12-31>

Sie können ein bestimmtes Datum aus verschiedenen Kombinationen von Argumenten erstellen

Date.new nimmt ganze Jahres-, Monats- und Tagesnummern entgegen
```
Date.new(1999, 12, 31) # => #<Date: 1999-12-31>
```
Date.ordinal nimmt Jahreszahl und Tag des Jahres als ganze Zahlen entgegen
```
Date.ordinal(1999, 365) # => #<Date: 1999-12-31>
```
Date.jd nimmt julianische Tagesnummer als ganze Zahl entgegen
```
Date.jd(2451544) # => #<Date: 1999-12-31>
```
Date.commercial nimmt kommerzielle Daten (Jahr, Woche, Wochentag) als ganze Zahlen entgegen
```
Date.commercial(1999, 52, 5) # => #<Date: 1999-12-31>
```

Date.parse nimmt einen String entgegen, den es heuristisch analysiert

Date.parse('1999-12-31')    # => #<Date: 1999-12-31>
Date.parse('31-12-1999')    # => #<Date: 1999-12-31>
Date.parse('1999-365')      # => #<Date: 1999-12-31>
Date.parse('1999-W52-5')    # => #<Date: 1999-12-31>

Date.strptime nimmt einen Datumsstring und einen Formatstring entgegen und analysiert dann den Datumsstring entsprechend dem Formatstring

Date.strptime('1999-12-31', '%Y-%m-%d')  # => #<Date: 1999-12-31>
Date.strptime('31-12-1999', '%d-%m-%Y')  # => #<Date: 1999-12-31>
Date.strptime('1999-365', '%Y-%j')       # => #<Date: 1999-12-31>
Date.strptime('1999-W52-5', '%G-W%V-%u') # => #<Date: 1999-12-31>
Date.strptime('1999 52 5', '%Y %U %w')   # => #<Date: 1999-12-31>
Date.strptime('1999 52 5', '%Y %W %u')   # => #<Date: 1999-12-31>
Date.strptime('fri31dec99', '%a%d%b%y')  # => #<Date: 1999-12-31>

Siehe auch die spezialisierten Methoden in „Spezialisierte Format-Strings“ in Formaten für Daten und Zeiten

Argument `limit`

Bestimmte Singleton-Methoden in Date, die String-Argumente parsen, nehmen auch ein optionales Schlüsselwortargument limit entgegen, das die Länge des String-Arguments begrenzen kann.

Wenn limit

Nicht-negativ ist: löst ArgumentError aus, wenn die String-Länge größer als limit ist.
Andere numerische Werte oder nil: ignoriert limit.
Andere nicht-numerische Werte: löst TypeError aus.

Constants

ABBR_DAYNAMES: Ein Array von Strings mit abgekürzten Tagesnamen in Englisch. Der erste ist „So“.
ABBR_MONTHNAMES: Ein Array von Strings mit abgekürzten Monatsnamen in Englisch. Das erste Element ist nil.
DAYNAMES: Ein Array von Strings mit den vollständigen Namen der Wochentage in Englisch. Der erste ist „Sonntag“.
ENGLAND: Die julianische Tagesnummer des Tages der Kalenderreform für England und seine Kolonien.
GREGORIAN: Die julianische Tagesnummer des Tages der Kalenderreform für den proleptischen gregorianischen Kalender.
ITALY: Die julianische Tagesnummer des Tages der Kalenderreform für Italien und einige katholische Länder.
JULIAN: Die julianische Tagesnummer des Tages der Kalenderreform für den proleptischen julianischen Kalender.
MONTHNAMES: Ein Array von Strings mit vollständigen Monatsnamen in Englisch. Das erste Element ist nil.

Öffentliche Klassenmethoden

_httpdate(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__httpdate(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein gültiges HTTP-Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT"
Date._httpdate(s)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"GMT", :offset=>0}

Verwandt: Date.httpdate (gibt ein Date-Objekt zurück).

_iso8601(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__iso8601(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein ISO 8601 formatiertes Datum enthalten sollte

d = Date.new(2001, 2, 3)
s = d.iso8601    # => "2001-02-03"
Date._iso8601(s) # => {:mday=>3, :year=>2001, :mon=>2}

Siehe Argument limit.

Verwandt: Date.iso8601 (gibt ein Date-Objekt zurück).

_jisx0301(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__jisx0301(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein gültiges JIS X 0301 Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.jisx0301    # => "H13.02.03"
Date._jisx0301(s) # => {:year=>2001, :mon=>2, :mday=>3}

Siehe Argument limit.

Verwandt: Date.jisx0301 (gibt ein Date-Objekt zurück).

_parse(string, comp = true, limit: 128) → hash

Source

static VALUE
date_s__parse(int argc, VALUE *argv, VALUE klass)
{
    return date_s__parse_internal(argc, argv, klass);
}

Hinweis: Diese Methode erkennt viele Formen in string, ist aber kein Validator. Für Formate siehe „Spezialisierte Format-Strings“ in Formaten für Daten und Zeiten

Wenn string kein gültiges Datum angibt, ist das Ergebnis unvorhersehbar; erwägen Sie stattdessen die Verwendung von Date._strptime.

Gibt einen Hash von Werten zurück, die aus string geparst wurden

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

Wenn comp true ist und das gegebene Jahr im Bereich (0..99) liegt, wird das aktuelle Jahrhundert bereitgestellt; andernfalls wird das Jahr wie angegeben übernommen

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

Siehe Argument limit.

Verwandt: Date.parse (gibt ein Date-Objekt zurück).

_rfc2822(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__rfc2822(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein gültiges RFC 2822 Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"
Date._rfc2822(s)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"+0000", :offset=>0}

Siehe Argument limit.

Verwandt: Date.rfc2822 (gibt ein Date-Objekt zurück).

_rfc3339(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__rfc3339(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein gültiges RFC 3339 Format sein sollte

d = Date.new(2001, 2, 3)
s = d.rfc3339     # => "2001-02-03T00:00:00+00:00"
Date._rfc3339(s)
# => {:year=>2001, :mon=>2, :mday=>3, :hour=>0, :min=>0, :sec=>0, :zone=>"+00:00", :offset=>0}

Siehe Argument limit.

Verwandt: Date.rfc3339 (gibt ein Date-Objekt zurück).

_rfc2822(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__rfc2822(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein gültiges RFC 2822 Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"
Date._rfc2822(s)
# => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"+0000", :offset=>0}

Siehe Argument limit.

Verwandt: Date.rfc2822 (gibt ein Date-Objekt zurück).

_strptime(string, format = '%F') → hash

Source

static VALUE
date_s__strptime(int argc, VALUE *argv, VALUE klass)
{
    return date_s__strptime_internal(argc, argv, klass, "%F");
}

Gibt einen Hash von Werten zurück, die aus string gemäß dem angegebenen format geparst wurden

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

Für andere Formate siehe Formate für Daten und Zeiten. (Im Gegensatz zu Date.strftime werden keine Flags und Breiten unterstützt.)

Siehe auch strptime(3).

Verwandt: Date.strptime (gibt ein Date-Objekt zurück).

_xmlschema(string, limit: 128) → hash

Source

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

    rb_scan_args(argc, argv, "1:", &str, &opt);
    if (!NIL_P(str)) str = check_limit(str, opt);

    return date__xmlschema(str);
}

Gibt einen Hash von Werten zurück, die aus string geparst wurden, welcher ein gültiges XML-Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.xmlschema    # => "2001-02-03"
Date._xmlschema(s) # => {:year=>2001, :mon=>2, :mday=>3}

Siehe Argument limit.

Verwandt: Date.xmlschema (gibt ein Date-Objekt zurück).

civil (*args)

Source

static VALUE
date_s_civil(int argc, VALUE *argv, VALUE klass)
{
    return date_initialize(argc, argv, d_lite_s_alloc_simple(klass));
}

Gleich wie Date.new.

commercial(cwyear = -4712, cweek = 1, cwday = 1, start = Date::ITALY) → date

Source

static VALUE
date_s_commercial(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vsg, y, fr, fr2, ret;
    int w, d;
    double sg;

    rb_scan_args(argc, argv, "04", &vy, &vw, &vd, &vsg);

    y = INT2FIX(-4712);
    w = 1;
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 4:
        val2sg(vsg, sg);
      case 3:
        check_numeric(vd, "cwday");
        num2int_with_frac(d, positive_inf);
      case 2:
        check_numeric(vw, "cweek");
        w = NUM2INT(vw);
      case 1:
        check_numeric(vy, "year");
        y = vy;
    }

    {
        VALUE nth;
        int ry, rw, rd, rjd, ns;

        if (!valid_commercial_p(y, w, d, sg,
                                &nth, &ry,
                                &rw, &rd, &rjd,
                                &ns))
            rb_raise(eDateError, "invalid date");

        ret = d_simple_new_internal(klass,
                                    nth, rjd,
                                    sg,
                                    0, 0, 0,
                                    HAVE_JD);
    }
    add_frac();
    return ret;
}

Gibt ein neues Date-Objekt zurück, das aus den Argumenten konstruiert wurde.

Argument cwyear gibt das Jahr an und sollte eine Ganzzahl sein.

Argument cweek gibt den Index der Woche innerhalb des Jahres an und sollte im Bereich (1..53) oder (-53..-1) liegen; in einigen Jahren sind 53 oder -53 außerhalb des Bereichs; wenn negativ, zählt rückwärts vom Ende des Jahres

Date.commercial(2022, 1, 1).to_s  # => "2022-01-03"
Date.commercial(2022, 52, 1).to_s # => "2022-12-26"

Argument cwday gibt den Index des Wochentags innerhalb der Woche an und sollte im Bereich (1..7) oder (-7..-1) liegen; 1 oder -7 ist Montag; wenn negativ, zählt rückwärts vom Ende der Woche

Date.commercial(2022, 1, 1).to_s  # => "2022-01-03"
Date.commercial(2022, 1, -7).to_s # => "2022-01-03"

Wenn cweek 1 ist

Wenn der 1. Januar ein Freitag, Samstag oder Sonntag ist, beginnt die erste Woche nach der.

Date::ABBR_DAYNAMES[Date.new(2023, 1, 1).wday] # => "Sun"
Date.commercial(2023, 1, 1).to_s # => "2023-01-02"
Date.commercial(2023, 1, 7).to_s # => "2023-01-08"

Andernfalls ist die erste Woche die Woche vom 1. Januar, was bedeuten kann, dass einige Tage auf das Vorjahr fallen

Date::ABBR_DAYNAMES[Date.new(2020, 1, 1).wday] # => "Wed"
Date.commercial(2020, 1, 1).to_s # => "2019-12-30"
Date.commercial(2020, 1, 7).to_s # => "2020-01-05"

Siehe Argument start.

Verwandt: Date.jd, Date.new, Date.ordinal.

gregorian_leap?(year) → true oder false

Source

static VALUE
date_s_gregorian_leap_p(VALUE klass, VALUE y)
{
    VALUE nth;
    int ry;

    check_numeric(y, "year");
    decode_year(y, -1, &nth, &ry);
    return f_boolcast(c_gregorian_leap_p(ry));
}

Gibt true zurück, wenn das angegebene Jahr ein Schaltjahr im proleptischen gregorianischen Kalender ist, andernfalls false

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

Verwandt: Date.julian_leap?.

httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
        hash = date_s__httpdate(argc2, argv2, klass);
        return d_new_by_frags(klass, hash, sg);
    }
}

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein gültiges HTTP-Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.httpdate   # => "Sat, 03 Feb 2001 00:00:00 GMT"
Date.httpdate(s) # => #<Date: 2001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._httpdate (gibt einen Hash zurück).

iso8601(string = '-4712-01-01', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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_DATE);
      case 1:
        sg = INT2FIX(DEFAULT_SG);
    }

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

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein ISO 8601 formatiertes Datum enthalten sollte

d = Date.new(2001, 2, 3)
s = d.iso8601   # => "2001-02-03"
Date.iso8601(s) # => #<Date: 2001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._iso8601 (gibt einen Hash zurück).

jd(jd = 0, start = Date::ITALY) → date

Source

static VALUE
date_s_jd(int argc, VALUE *argv, VALUE klass)
{
    VALUE vjd, vsg, jd, fr, fr2, ret;
    double sg;

    rb_scan_args(argc, argv, "02", &vjd, &vsg);

    jd = INT2FIX(0);
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 2:
        val2sg(vsg, sg);
      case 1:
        check_numeric(vjd, "jd");
        num2num_with_frac(jd, positive_inf);
    }

    {
        VALUE nth;
        int rjd;

        decode_jd(jd, &nth, &rjd);
        ret = d_simple_new_internal(klass,
                                    nth, rjd,
                                    sg,
                                    0, 0, 0,
                                    HAVE_JD);
    }
    add_frac();
    return ret;
}

Gibt ein neues Date-Objekt zurück, das aus den Argumenten gebildet wird

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

Das zurückgegebene Datum ist

gregorianisch, wenn das Argument größer oder gleich start ist

Date::ITALY                         # => 2299161
Date.jd(Date::ITALY).gregorian?     # => true
Date.jd(Date::ITALY + 1).gregorian? # => true

julianisch, andernfalls

Date.jd(Date::ITALY - 1).julian?    # => true

Siehe Argument start.

Verwandt: Date.new.

jisx0301(string = '-4712-01-01', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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_DATE);
      case 1:
        sg = INT2FIX(DEFAULT_SG);
    }

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

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein gültiges JIS X 0301 Format sein sollte

d = Date.new(2001, 2, 3)
s = d.jisx0301   # => "H13.02.03"
Date.jisx0301(s) # => #<Date: 2001-02-03>

Für Jahre ohne Ära wird das Legacy-Format Heisei angenommen.

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

Siehe

Argument start.
Argument limit.

Verwandt: Date._jisx0301 (gibt einen Hash zurück).

json_create (object)

Source

# File ext/json/lib/json/add/date.rb, line 10
def self.json_create(object)
  civil(*object.values_at('y', 'm', 'd', 'sg'))
end

Siehe as_json.

julian_leap?(year) → true oder false

Source

static VALUE
date_s_julian_leap_p(VALUE klass, VALUE y)
{
    VALUE nth;
    int ry;

    check_numeric(y, "year");
    decode_year(y, +1, &nth, &ry);
    return f_boolcast(c_julian_leap_p(ry));
}

Gibt true zurück, wenn das angegebene Jahr ein Schaltjahr im proleptischen julianischen Kalender ist, andernfalls false

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

Verwandt: Date.gregorian_leap?.

gregorian_leap?(year) → true oder false

Source

static VALUE
date_s_gregorian_leap_p(VALUE klass, VALUE y)
{
    VALUE nth;
    int ry;

    check_numeric(y, "year");
    decode_year(y, -1, &nth, &ry);
    return f_boolcast(c_gregorian_leap_p(ry));
}

Gibt true zurück, wenn das angegebene Jahr ein Schaltjahr im proleptischen gregorianischen Kalender ist, andernfalls false

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

Verwandt: Date.julian_leap?.

new(year = -4712, month = 1, mday = 1, start = Date::ITALY) → date

Source

static VALUE
date_initialize(int argc, VALUE *argv, VALUE self)
{
    VALUE vy, vm, vd, vsg, y, fr, fr2, ret;
    int m, d;
    double sg;
    struct SimpleDateData *dat = rb_check_typeddata(self, &d_lite_type);

    if (!simple_dat_p(dat)) {
        rb_raise(rb_eTypeError, "Date expected");
    }

    rb_scan_args(argc, argv, "04", &vy, &vm, &vd, &vsg);

    y = INT2FIX(-4712);
    m = 1;
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 4:
        val2sg(vsg, sg);
      case 3:
        check_numeric(vd, "day");
        num2int_with_frac(d, positive_inf);
      case 2:
        check_numeric(vm, "month");
        m = NUM2INT(vm);
      case 1:
        check_numeric(vy, "year");
        y = vy;
    }

    if (guess_style(y, sg) < 0) {
        VALUE nth;
        int ry, rm, rd;

        if (!valid_gregorian_p(y, m, d,
                               &nth, &ry,
                               &rm, &rd))
            rb_raise(eDateError, "invalid date");

        set_to_simple(self, dat, nth, 0, sg, ry, rm, rd, HAVE_CIVIL);
    }
    else {
        VALUE nth;
        int ry, rm, rd, rjd, ns;

        if (!valid_civil_p(y, m, d, sg,
                           &nth, &ry,
                           &rm, &rd, &rjd,
                           &ns))
            rb_raise(eDateError, "invalid date");

        set_to_simple(self, dat, nth, rjd, sg, ry, rm, rd, HAVE_JD | HAVE_CIVIL);
    }
    ret = self;
    add_frac();
    return ret;
}

Gibt ein neues Date-Objekt zurück, das aus den angegebenen Argumenten konstruiert wurde

Date.new(2022).to_s        # => "2022-01-01"
Date.new(2022, 2).to_s     # => "2022-02-01"
Date.new(2022, 2, 4).to_s  # => "2022-02-04"

Argument month sollte im Bereich (1..12) oder (-12..-1) liegen; wenn das Argument negativ ist, zählt es rückwärts vom Ende des Jahres

Date.new(2022, -11, 4).to_s # => "2022-02-04"

Argument mday sollte im Bereich (1..n) oder (-n..-1) liegen, wobei n die Anzahl der Tage im Monat ist; wenn das Argument negativ ist, zählt es rückwärts vom Ende des Monats.

Siehe Argument start.

Verwandt: Date.jd.

ordinal(year = -4712, yday = 1, start = Date::ITALY) → date

Source

static VALUE
date_s_ordinal(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vd, vsg, y, fr, fr2, ret;
    int d;
    double sg;

    rb_scan_args(argc, argv, "03", &vy, &vd, &vsg);

    y = INT2FIX(-4712);
    d = 1;
    fr2 = INT2FIX(0);
    sg = DEFAULT_SG;

    switch (argc) {
      case 3:
        val2sg(vsg, sg);
      case 2:
        check_numeric(vd, "yday");
        num2int_with_frac(d, positive_inf);
      case 1:
        check_numeric(vy, "year");
        y = vy;
    }

    {
        VALUE nth;
        int ry, rd, rjd, ns;

        if (!valid_ordinal_p(y, d, sg,
                             &nth, &ry,
                             &rd, &rjd,
                             &ns))
            rb_raise(eDateError, "invalid date");

        ret = d_simple_new_internal(klass,
                                     nth, rjd,
                                     sg,
                                     0, 0, 0,
                                     HAVE_JD);
    }
    add_frac();
    return ret;
}

Gibt ein neues Date-Objekt zurück, das aus den Argumenten gebildet wird.

Ohne Argumente wird das Datum für den 1. Januar -4712 zurückgegeben

Date.ordinal.to_s # => "-4712-01-01"

Mit dem Argument year wird das Datum für den 1. Januar dieses Jahres zurückgegeben

Date.ordinal(2001).to_s  # => "2001-01-01"
Date.ordinal(-2001).to_s # => "-2001-01-01"

Mit positivem Argument yday == n, gibt es das Datum für den nth Tag des angegebenen Jahres zurück

Date.ordinal(2001, 14).to_s # => "2001-01-14"

Mit negativem Argument yday zählt es rückwärts vom Ende des Jahres

Date.ordinal(2001, -14).to_s # => "2001-12-18"

Löst eine Ausnahme aus, wenn yday null oder außerhalb des Bereichs liegt.

Siehe Argument start.

Verwandt: Date.jd, Date.new.

parse(string = '-4712-01-01', comp = true, start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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_DATE);
      case 1:
        comp = Qtrue;
      case 2:
        sg = INT2FIX(DEFAULT_SG);
    }

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

Hinweis: Diese Methode erkennt viele Formen in string, ist aber kein Validator. Für Formate siehe „Spezialisierte Format-Strings“ in Formaten für Daten und Zeiten. Wenn string kein gültiges Datum angibt, ist das Ergebnis unvorhersehbar; erwägen Sie stattdessen die Verwendung von Date._strptime.

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück

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>

Wenn comp true ist und das gegebene Jahr im Bereich (0..99) liegt, wird das aktuelle Jahrhundert bereitgestellt; andernfalls wird das Jahr wie angegeben übernommen

Date.parse('01-02-03', true)  # => #<Date: 2001-02-03>
Date.parse('01-02-03', false) # => #<Date: 0001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._parse (gibt einen Hash zurück).

rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
        hash = date_s__rfc2822(argc2, argv2, klass);
        return d_new_by_frags(klass, hash, sg);
    }
}

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein gültiges RFC 2822 Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.rfc2822   # => "Sat, 3 Feb 2001 00:00:00 +0000"
Date.rfc2822(s) # => #<Date: 2001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._rfc2822 (gibt einen Hash zurück).

rfc3339(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
        hash = date_s__rfc3339(argc2, argv2, klass);
        return d_new_by_frags(klass, hash, sg);
    }
}

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein gültiges RFC 3339 Format sein sollte

d = Date.new(2001, 2, 3)
s = d.rfc3339   # => "2001-02-03T00:00:00+00:00"
Date.rfc3339(s) # => #<Date: 2001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._rfc3339 (gibt einen Hash zurück).

rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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;
        if (!NIL_P(opt)) argv2[argc2++] = opt;
        hash = date_s__rfc2822(argc2, argv2, klass);
        return d_new_by_frags(klass, hash, sg);
    }
}

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein gültiges RFC 2822 Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.rfc2822   # => "Sat, 3 Feb 2001 00:00:00 +0000"
Date.rfc2822(s) # => #<Date: 2001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._rfc2822 (gibt einen Hash zurück).

strptime(string = '-4712-01-01', format = '%F', start = Date::ITALY) → date

Source

static VALUE
date_s_strptime(int argc, VALUE *argv, VALUE klass)
{
    VALUE str, fmt, sg;

    rb_scan_args(argc, argv, "03", &str, &fmt, &sg);

    switch (argc) {
      case 0:
        str = rb_str_new2(JULIAN_EPOCH_DATE);
      case 1:
        fmt = rb_str_new2("%F");
      case 2:
        sg = INT2FIX(DEFAULT_SG);
    }

    {
        VALUE argv2[2], hash;

        argv2[0] = str;
        argv2[1] = fmt;
        hash = date_s__strptime(2, argv2, klass);
        return d_new_by_frags(klass, hash, sg);
    }
}

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, entsprechend dem angegebenen format

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>

Für andere Formate siehe Formate für Daten und Zeiten. (Im Gegensatz zu Date.strftime werden keine Flags und Breiten unterstützt.)

Siehe Argument start.

Siehe auch strptime(3).

Verwandt: Date._strptime (gibt einen Hash zurück).

today(start = Date::ITALY) → date

Source

static VALUE
date_s_today(int argc, VALUE *argv, VALUE klass)
{
    VALUE vsg, nth, ret;
    double sg;
    time_t t;
    struct tm tm;
    int y, ry, m, d;

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

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

    if (time(&t) == -1)
        rb_sys_fail("time");
    tzset();
    if (!localtime_r(&t, &tm))
        rb_sys_fail("localtime");

    y = tm.tm_year + 1900;
    m = tm.tm_mon + 1;
    d = tm.tm_mday;

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

    ret = d_simple_new_internal(klass,
                                nth, 0,
                                GREGORIAN,
                                ry, m, d,
                                HAVE_CIVIL);
    {
        get_d1(ret);
        set_sg(dat, sg);
    }
    return ret;
}

Gibt ein neues Date-Objekt zurück, das aus dem aktuellen Datum konstruiert wurde

Date.today.to_s # => "2022-07-06"

Siehe Argument start.

valid_civil?(year, month, mday, start = Date::ITALY) → true oder false

Source

static VALUE
date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vd, vsg;
    VALUE argv2[4];

    rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg);

    RETURN_FALSE_UNLESS_NUMERIC(vy);
    RETURN_FALSE_UNLESS_NUMERIC(vm);
    RETURN_FALSE_UNLESS_NUMERIC(vd);
    argv2[0] = vy;
    argv2[1] = vm;
    argv2[2] = vd;
    if (argc < 4)
        argv2[3] = INT2FIX(DEFAULT_SG);
    else
        argv2[3] = vsg;

    if (NIL_P(valid_civil_sub(4, argv2, klass, 0)))
        return Qfalse;
    return Qtrue;
}

Gibt true zurück, wenn die Argumente ein gültiges ordinales Datum definieren, andernfalls false

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

Siehe Argument start.

Verwandt: Date.jd, Date.new.

valid_commercial?(cwyear, cweek, cwday, start = Date::ITALY) → true oder false

Source

static VALUE
date_s_valid_commercial_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vw, vd, vsg;
    VALUE argv2[4];

    rb_scan_args(argc, argv, "31", &vy, &vw, &vd, &vsg);

    RETURN_FALSE_UNLESS_NUMERIC(vy);
    RETURN_FALSE_UNLESS_NUMERIC(vw);
    RETURN_FALSE_UNLESS_NUMERIC(vd);
    argv2[0] = vy;
    argv2[1] = vw;
    argv2[2] = vd;
    if (argc < 4)
        argv2[3] = INT2FIX(DEFAULT_SG);
    else
        argv2[3] = vsg;

    if (NIL_P(valid_commercial_sub(4, argv2, klass, 0)))
        return Qfalse;
    return Qtrue;
}

Gibt true zurück, wenn die Argumente ein gültiges kommerzielles Datum definieren, andernfalls false

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

Siehe Date.commercial.

Siehe Argument start.

Verwandt: Date.jd, Date.commercial.

valid_civil?(year, month, mday, start = Date::ITALY) → true oder false

Source

static VALUE
date_s_valid_civil_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vm, vd, vsg;
    VALUE argv2[4];

    rb_scan_args(argc, argv, "31", &vy, &vm, &vd, &vsg);

    RETURN_FALSE_UNLESS_NUMERIC(vy);
    RETURN_FALSE_UNLESS_NUMERIC(vm);
    RETURN_FALSE_UNLESS_NUMERIC(vd);
    argv2[0] = vy;
    argv2[1] = vm;
    argv2[2] = vd;
    if (argc < 4)
        argv2[3] = INT2FIX(DEFAULT_SG);
    else
        argv2[3] = vsg;

    if (NIL_P(valid_civil_sub(4, argv2, klass, 0)))
        return Qfalse;
    return Qtrue;
}

Gibt true zurück, wenn die Argumente ein gültiges ordinales Datum definieren, andernfalls false

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

Siehe Argument start.

Verwandt: Date.jd, Date.new.

valid_jd?(jd, start = Date::ITALY) → true

Source

static VALUE
date_s_valid_jd_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vjd, vsg;
    VALUE argv2[2];

    rb_scan_args(argc, argv, "11", &vjd, &vsg);

    RETURN_FALSE_UNLESS_NUMERIC(vjd);
    argv2[0] = vjd;
    if (argc < 2)
        argv2[1] = INT2FIX(DEFAULT_SG);
    else
        argv2[1] = vsg;

    if (NIL_P(valid_jd_sub(2, argv2, klass, 0)))
        return Qfalse;
    return Qtrue;
}

Zur Kompatibilität implementiert; gibt true zurück, es sei denn, jd ist ungültig (d.h. keine Numeric).

Date.valid_jd?(2451944) # => true

Siehe Argument start.

Verwandt: Date.jd.

valid_ordinal?(year, yday, start = Date::ITALY) → true oder false

Source

static VALUE
date_s_valid_ordinal_p(int argc, VALUE *argv, VALUE klass)
{
    VALUE vy, vd, vsg;
    VALUE argv2[3];

    rb_scan_args(argc, argv, "21", &vy, &vd, &vsg);

    RETURN_FALSE_UNLESS_NUMERIC(vy);
    RETURN_FALSE_UNLESS_NUMERIC(vd);
    argv2[0] = vy;
    argv2[1] = vd;
    if (argc < 3)
        argv2[2] = INT2FIX(DEFAULT_SG);
    else
        argv2[2] = vsg;

    if (NIL_P(valid_ordinal_sub(3, argv2, klass, 0)))
        return Qfalse;
    return Qtrue;
}

Gibt true zurück, wenn die Argumente ein gültiges ordinales Datum definieren, andernfalls false

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

Siehe Argument start.

Verwandt: Date.jd, Date.ordinal.

xmlschema(string = '-4712-01-01', start = Date::ITALY, limit: 128) → date

Source

static VALUE
date_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_DATE);
      case 1:
        sg = INT2FIX(DEFAULT_SG);
    }

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

Gibt ein neues Date-Objekt mit aus string geparsten Werten zurück, welches ein gültiges XML-Datumsformat sein sollte

d = Date.new(2001, 2, 3)
s = d.xmlschema   # => "2001-02-03"
Date.xmlschema(s) # => #<Date: 2001-02-03>

Siehe

Argument start.
Argument limit.

Verwandt: Date._xmlschema (gibt einen Hash zurück).

Öffentliche Instanzmethoden

d + other → date

Source

static VALUE
d_lite_plus(VALUE self, VALUE other)
{
    int try_rational = 1;
    get_d1(self);

  again:
    switch (TYPE(other)) {
      case T_FIXNUM:
        {
            VALUE nth;
            long t;
            int jd;

            nth = m_nth(dat);
            t = FIX2LONG(other);
            if (DIV(t, CM_PERIOD)) {
                nth = f_add(nth, INT2FIX(DIV(t, CM_PERIOD)));
                t = MOD(t, CM_PERIOD);
            }

            if (!t)
                jd = m_jd(dat);
            else {
                jd = m_jd(dat) + (int)t;
                canonicalize_jd(nth, jd);
            }

            if (simple_dat_p(dat))
                return d_simple_new_internal(rb_obj_class(self),
                                             nth, jd,
                                             dat->s.sg,
                                             0, 0, 0,
                                             (dat->s.flags | HAVE_JD) &
                                             ~HAVE_CIVIL);
            else
                return d_complex_new_internal(rb_obj_class(self),
                                              nth, jd,
                                              dat->c.df, dat->c.sf,
                                              dat->c.of, dat->c.sg,
                                              0, 0, 0,
#ifndef USE_PACK
                                              dat->c.hour,
                                              dat->c.min,
                                              dat->c.sec,
#else
                                              EX_HOUR(dat->c.pc),
                                              EX_MIN(dat->c.pc),
                                              EX_SEC(dat->c.pc),
#endif
                                              (dat->c.flags | HAVE_JD) &
                                              ~HAVE_CIVIL);
        }
        break;
      case T_BIGNUM:
        {
            VALUE nth;
            int jd, s;

            if (f_positive_p(other))
                s = +1;
            else {
                s = -1;
                other = f_negate(other);
            }

            nth = f_idiv(other, INT2FIX(CM_PERIOD));
            jd = FIX2INT(f_mod(other, INT2FIX(CM_PERIOD)));

            if (s < 0) {
                nth = f_negate(nth);
                jd = -jd;
            }

            if (!jd)
                jd = m_jd(dat);
            else {
                jd = m_jd(dat) + jd;
                canonicalize_jd(nth, jd);
            }

            if (f_zero_p(nth))
                nth = m_nth(dat);
            else
                nth = f_add(m_nth(dat), nth);

            if (simple_dat_p(dat))
                return d_simple_new_internal(rb_obj_class(self),
                                             nth, jd,
                                             dat->s.sg,
                                             0, 0, 0,
                                             (dat->s.flags | HAVE_JD) &
                                             ~HAVE_CIVIL);
            else
                return d_complex_new_internal(rb_obj_class(self),
                                              nth, jd,
                                              dat->c.df, dat->c.sf,
                                              dat->c.of, dat->c.sg,
                                              0, 0, 0,
#ifndef USE_PACK
                                              dat->c.hour,
                                              dat->c.min,
                                              dat->c.sec,
#else
                                              EX_HOUR(dat->c.pc),
                                              EX_MIN(dat->c.pc),
                                              EX_SEC(dat->c.pc),
#endif
                                              (dat->c.flags | HAVE_JD) &
                                              ~HAVE_CIVIL);
        }
        break;
      case T_FLOAT:
        {
            double jd, o, tmp;
            int s, df;
            VALUE nth, sf;

            o = RFLOAT_VALUE(other);

            if (o > 0)
                s = +1;
            else {
                s = -1;
                o = -o;
            }

            o = modf(o, &tmp);

            if (!floor(tmp / CM_PERIOD)) {
                nth = INT2FIX(0);
                jd = (int)tmp;
            }
            else {
                double i, f;

                f = modf(tmp / CM_PERIOD, &i);
                nth = f_floor(DBL2NUM(i));
                jd = (int)(f * CM_PERIOD);
            }

            o *= DAY_IN_SECONDS;
            o = modf(o, &tmp);
            df = (int)tmp;
            o *= SECOND_IN_NANOSECONDS;
            sf = INT2FIX((int)round(o));

            if (s < 0) {
                jd = -jd;
                df = -df;
                sf = f_negate(sf);
            }

            if (f_zero_p(sf))
                sf = m_sf(dat);
            else {
                sf = f_add(m_sf(dat), sf);
                if (f_lt_p(sf, INT2FIX(0))) {
                    df -= 1;
                    sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS));
                }
                else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) {
                    df += 1;
                    sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS));
                }
            }

            if (!df)
                df = m_df(dat);
            else {
                df = m_df(dat) + df;
                if (df < 0) {
                    jd -= 1;
                    df += DAY_IN_SECONDS;
                }
                else if (df >= DAY_IN_SECONDS) {
                    jd += 1;
                    df -= DAY_IN_SECONDS;
                }
            }

            if (!jd)
                jd = m_jd(dat);
            else {
                jd = m_jd(dat) + jd;
                canonicalize_jd(nth, jd);
            }

            if (f_zero_p(nth))
                nth = m_nth(dat);
            else
                nth = f_add(m_nth(dat), nth);

            if (!df && f_zero_p(sf) && !m_of(dat))
                return d_simple_new_internal(rb_obj_class(self),
                                             nth, (int)jd,
                                             m_sg(dat),
                                             0, 0, 0,
                                             (dat->s.flags | HAVE_JD) &
                                             ~(HAVE_CIVIL | HAVE_TIME |
                                               COMPLEX_DAT));
            else
                return d_complex_new_internal(rb_obj_class(self),
                                              nth, (int)jd,
                                              df, sf,
                                              m_of(dat), m_sg(dat),
                                              0, 0, 0,
                                              0, 0, 0,
                                              (dat->c.flags |
                                               HAVE_JD | HAVE_DF) &
                                              ~(HAVE_CIVIL | HAVE_TIME));
        }
        break;
      default:
        expect_numeric(other);
        other = f_to_r(other);
        if (!k_rational_p(other)) {
            if (!try_rational) Check_Type(other, T_RATIONAL);
            try_rational = 0;
            goto again;
        }
        /* fall through */
      case T_RATIONAL:
        {
            VALUE nth, sf, t;
            int jd, df, s;

            if (wholenum_p(other)) {
                other = rb_rational_num(other);
                goto again;
            }

            if (f_positive_p(other))
                s = +1;
            else {
                s = -1;
                other = f_negate(other);
            }

            nth = f_idiv(other, INT2FIX(CM_PERIOD));
            t = f_mod(other, INT2FIX(CM_PERIOD));

            jd = FIX2INT(f_idiv(t, INT2FIX(1)));
            t = f_mod(t, INT2FIX(1));

            t = f_mul(t, INT2FIX(DAY_IN_SECONDS));
            df = FIX2INT(f_idiv(t, INT2FIX(1)));
            t = f_mod(t, INT2FIX(1));

            sf = f_mul(t, INT2FIX(SECOND_IN_NANOSECONDS));

            if (s < 0) {
                nth = f_negate(nth);
                jd = -jd;
                df = -df;
                sf = f_negate(sf);
            }

            if (f_zero_p(sf))
                sf = m_sf(dat);
            else {
                sf = f_add(m_sf(dat), sf);
                if (f_lt_p(sf, INT2FIX(0))) {
                    df -= 1;
                    sf = f_add(sf, INT2FIX(SECOND_IN_NANOSECONDS));
                }
                else if (f_ge_p(sf, INT2FIX(SECOND_IN_NANOSECONDS))) {
                    df += 1;
                    sf = f_sub(sf, INT2FIX(SECOND_IN_NANOSECONDS));
                }
            }

            if (!df)
                df = m_df(dat);
            else {
                df = m_df(dat) + df;
                if (df < 0) {
                    jd -= 1;
                    df += DAY_IN_SECONDS;
                }
                else if (df >= DAY_IN_SECONDS) {
                    jd += 1;
                    df -= DAY_IN_SECONDS;
                }
            }

            if (!jd)
                jd = m_jd(dat);
            else {
                jd = m_jd(dat) + jd;
                canonicalize_jd(nth, jd);
            }

            if (f_zero_p(nth))
                nth = m_nth(dat);
            else
                nth = f_add(m_nth(dat), nth);

            if (!df && f_zero_p(sf) && !m_of(dat))
                return d_simple_new_internal(rb_obj_class(self),
                                             nth, jd,
                                             m_sg(dat),
                                             0, 0, 0,
                                             (dat->s.flags | HAVE_JD) &
                                             ~(HAVE_CIVIL | HAVE_TIME |
                                               COMPLEX_DAT));
            else
                return d_complex_new_internal(rb_obj_class(self),
                                              nth, jd,
                                              df, sf,
                                              m_of(dat), m_sg(dat),
                                              0, 0, 0,
                                              0, 0, 0,
                                              (dat->c.flags |
                                               HAVE_JD | HAVE_DF) &
                                              ~(HAVE_CIVIL | HAVE_TIME));
        }
        break;
    }
}

Gibt ein Datumsobjekt zurück, das other Tage nach self liegt. Other sollte ein numerischer Wert sein. Wenn other ein Bruch ist, wird angenommen, dass seine Präzision höchstens Nanosekunden beträgt.

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

d - other → date oder rational

Source

static VALUE
d_lite_minus(VALUE self, VALUE other)
{
    if (k_date_p(other))
        return minus_dd(self, other);

    switch (TYPE(other)) {
      case T_FIXNUM:
        return d_lite_plus(self, LONG2NUM(-FIX2LONG(other)));
      case T_FLOAT:
        return d_lite_plus(self, DBL2NUM(-RFLOAT_VALUE(other)));
      default:
        expect_numeric(other);
        /* fall through */
      case T_BIGNUM:
      case T_RATIONAL:
        return d_lite_plus(self, f_negate(other));
    }
}

Wenn other ein Datumsobjekt ist, gibt es eine Rational zurück, deren Wert die Differenz zwischen den beiden Daten in Tagen ist. Wenn other ein numerischer Wert ist, gibt es ein Datumsobjekt zurück, das other Tage vor self liegt. Wenn other ein Bruch ist, wird angenommen, dass seine Präzision höchstens Nanosekunden beträgt.

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)

d << n → date

Source

static VALUE
d_lite_lshift(VALUE self, VALUE other)
{
    expect_numeric(other);
    return d_lite_rshift(self, f_negate(other));
}

Gibt ein neues Date-Objekt zurück, das das Datum n Monate früher darstellt; n sollte eine Zahl sein

(Date.new(2001, 2, 3) << 1).to_s  # => "2001-01-03"
(Date.new(2001, 2, 3) << -2).to_s # => "2001-04-03"

Wenn derselbe Tag für den neuen Monat nicht existiert, wird stattdessen der letzte Tag dieses Monats verwendet

(Date.new(2001, 3, 31) << 1).to_s  # => "2001-02-28"
(Date.new(2001, 3, 31) << -6).to_s # => "2001-09-30"

Dies führt zu den folgenden, möglicherweise unerwarteten Verhaltensweisen

d0 = Date.new(2001, 3, 31)
d0 << 2      # => #<Date: 2001-01-31>
d0 << 1 << 1 # => #<Date: 2001-01-28>

d0 = Date.new(2001, 3, 31)
d1 = d0 << 1  # => #<Date: 2001-02-28>
d2 = d1 << -1 # => #<Date: 2001-03-28>

self <=> other → -1, 0, 1 oder nil

Source

static VALUE
d_lite_cmp(VALUE self, VALUE other)
{
    if (!k_date_p(other))
        return cmp_gen(self, other);

    {
        get_d2(self, other);

        if (!(simple_dat_p(adat) && simple_dat_p(bdat) &&
              m_gregorian_p(adat) == m_gregorian_p(bdat)))
            return cmp_dd(self, other);

        {
            VALUE a_nth, b_nth;
            int a_jd, b_jd;

            m_canonicalize_jd(self, adat);
            m_canonicalize_jd(other, bdat);
            a_nth = m_nth(adat);
            b_nth = m_nth(bdat);
            if (f_eqeq_p(a_nth, b_nth)) {
                a_jd = m_jd(adat);
                b_jd = m_jd(bdat);
                if (a_jd == b_jd) {
                    return INT2FIX(0);
                }
                else if (a_jd < b_jd) {
                    return INT2FIX(-1);
                }
                else {
                    return INT2FIX(1);
                }
            }
            else if (f_lt_p(a_nth, b_nth)) {
                return INT2FIX(-1);
            }
            else {
                return INT2FIX(1);
            }
        }
    }
}

Vergleicht self und other und gibt zurück

-1, wenn other größer ist.
0, wenn die beiden gleich sind.
1, wenn other kleiner ist.
nil, wenn die beiden nicht vergleichbar sind.

Argument other kann sein

Ein weiteres Date-Objekt

d = Date.new(2022, 7, 27) # => #<Date: 2022-07-27 ((2459788j,0s,0n),+0s,2299161j)>
prev_date = d.prev_day    # => #<Date: 2022-07-26 ((2459787j,0s,0n),+0s,2299161j)>
next_date = d.next_day    # => #<Date: 2022-07-28 ((2459789j,0s,0n),+0s,2299161j)>
d <=> next_date           # => -1
d <=> d                   # => 0
d <=> prev_date           # => 1

Ein DateTime-Objekt

d <=> DateTime.new(2022, 7, 26) # => 1
d <=> DateTime.new(2022, 7, 27) # => 0
d <=> DateTime.new(2022, 7, 28) # => -1

Eine Zahl (vergleicht self.ajd mit other)

d <=> 2459788 # => -1
d <=> 2459787 # => 1
d <=> 2459786 # => 1
d <=> d.ajd   # => 0

Jedes andere Objekt
```
d <=> Object.new # => nil
```

self === other → true, false oder nil.

Source

static VALUE
d_lite_equal(VALUE self, VALUE other)
{
    if (!k_date_p(other))
        return equal_gen(self, other);

    {
        get_d2(self, other);

        if (!(m_gregorian_p(adat) == m_gregorian_p(bdat)))
            return equal_gen(self, other);

        {
            VALUE a_nth, b_nth;
            int a_jd, b_jd;

            m_canonicalize_jd(self, adat);
            m_canonicalize_jd(other, bdat);
            a_nth = m_nth(adat);
            b_nth = m_nth(bdat);
            a_jd = m_local_jd(adat);
            b_jd = m_local_jd(bdat);
            if (f_eqeq_p(a_nth, b_nth) &&
                a_jd == b_jd)
                return Qtrue;
            return Qfalse;
        }
    }
}

Gibt true zurück, wenn self und other dasselbe Datum darstellen, false, wenn nicht, nil, wenn die beiden nicht vergleichbar sind.

Argument other kann sein

Ein weiteres Date-Objekt

d = Date.new(2022, 7, 27) # => #<Date: 2022-07-27 ((2459788j,0s,0n),+0s,2299161j)>
prev_date = d.prev_day    # => #<Date: 2022-07-26 ((2459787j,0s,0n),+0s,2299161j)>
next_date = d.next_day    # => #<Date: 2022-07-28 ((2459789j,0s,0n),+0s,2299161j)>
d === prev_date           # => false
d === d                   # => true
d === next_date           # => false

Ein DateTime-Objekt

d === DateTime.new(2022, 7, 26) # => false
d === DateTime.new(2022, 7, 27) # => true
d === DateTime.new(2022, 7, 28) # => false

Eine Zahl (vergleicht self.jd mit other)

d === 2459788 # => true
d === 2459787 # => false
d === 2459786 # => false
d === d.jd    # => true

Ein nicht vergleichbares Objekt
```
d === Object.new # => nil
```

d >> n → new_date

Source

static VALUE
d_lite_rshift(VALUE self, VALUE other)
{
    VALUE t, y, nth, rjd2;
    int m, d, rjd;
    double sg;

    get_d1(self);
    t = f_add3(f_mul(m_real_year(dat), INT2FIX(12)),
               INT2FIX(m_mon(dat) - 1),
               other);
    if (FIXNUM_P(t)) {
        long it = FIX2LONG(t);
        y = LONG2NUM(DIV(it, 12));
        it = MOD(it, 12);
        m = (int)it + 1;
    }
    else {
        y = f_idiv(t, INT2FIX(12));
        t = f_mod(t, INT2FIX(12));
        m = FIX2INT(t) + 1;
    }
    d = m_mday(dat);
    sg = m_sg(dat);

    while (1) {
        int ry, rm, rd, ns;

        if (valid_civil_p(y, m, d, sg,
                          &nth, &ry,
                          &rm, &rd, &rjd, &ns))
            break;
        if (--d < 1)
            rb_raise(eDateError, "invalid date");
    }
    encode_jd(nth, rjd, &rjd2);
    return d_lite_plus(self, f_sub(rjd2, m_real_local_jd(dat)));
}

Gibt ein neues Date-Objekt zurück, das das Datum n Monate später darstellt; n sollte eine Zahl sein

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

Wenn derselbe Tag für den neuen Monat nicht existiert, wird stattdessen der letzte Tag dieses Monats verwendet

(Date.new(2001, 1, 31) >> 1).to_s  # => "2001-02-28"
(Date.new(2001, 1, 31) >> -4).to_s # => "2000-09-30"

Dies führt zu den folgenden, möglicherweise unerwarteten Verhaltensweisen

d0 = Date.new(2001, 1, 31)
d1 = d0 >> 1 # => #<Date: 2001-02-28>
d2 = d1 >> 1 # => #<Date: 2001-03-28>

d0 = Date.new(2001, 1, 31)
d1 = d0 >> 1  # => #<Date: 2001-02-28>
d2 = d1 >> -1 # => #<Date: 2001-01-28>

ajd → rational

Source

static VALUE
d_lite_ajd(VALUE self)
{
    get_d1(self);
    return m_ajd(dat);
}

Gibt die astronomische julianische Tagesnummer zurück. Dies ist eine Bruchzahl, die nicht durch den Offset angepasst wird.

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

amjd → rational

Source

static VALUE
d_lite_amjd(VALUE self)
{
    get_d1(self);
    return m_amjd(dat);
}

Gibt die astronomische modifizierte julianische Tagesnummer zurück. Dies ist eine Bruchzahl, die nicht durch den Offset angepasst wird.

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

as_json (*)

Source

# File ext/json/lib/json/add/date.rb, line 32
def as_json(*)
  {
    JSON.create_id => self.class.name,
    'y' => year,
    'm' => month,
    'd' => day,
    'sg' => start,
  }
end

Die Methoden Date#as_json und Date.json_create können verwendet werden, um ein Date-Objekt zu serialisieren und zu deserialisieren; siehe Marshal.

Die Methode Date#as_json serialisiert self und gibt einen 2-elementigen Hash zurück, der self darstellt

require 'json/add/date'
x = Date.today.as_json
# => {"json_class"=>"Date", "y"=>2023, "m"=>11, "d"=>21, "sg"=>2299161.0}

Die Methode JSON.create deserialisiert einen solchen Hash und gibt ein Date-Objekt zurück

Date.json_create(x)
# => #<Date: 2023-11-21 ((2460270j,0s,0n),+0s,2299161j)>

asctime → string

Source

static VALUE
d_lite_asctime(VALUE self)
{
    return strftimev("%a %b %e %H:%M:%S %Y", self, set_tmx);
}

Entspricht strftime mit dem Argument '%a %b %e %T %Y' (oder seiner Kurzform '%c')

Date.new(2001, 2, 3).asctime # => "Sat Feb  3 00:00:00 2001"

Siehe asctime.

Auch alias: ctime

ctime

Alias für: asctime

cwday → integer

Source

static VALUE
d_lite_cwday(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_cwday(dat));
}

Gibt den kommerziellen Tages-Wochentagsindex für self zurück (siehe Date.commercial); 1 ist Montag

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

cweek → integer

Source

static VALUE
d_lite_cweek(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_cweek(dat));
}

Gibt den kommerziellen Wochenindex für self zurück (siehe Date.commercial)

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

cwyear → integer

Source

static VALUE
d_lite_cwyear(VALUE self)
{
    get_d1(self);
    return m_real_cwyear(dat);
}

Gibt das kommerzielle Jahr für self zurück (siehe Date.commercial)

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

day

Alias für: mday

day_fraction → rational

Source

static VALUE
d_lite_day_fraction(VALUE self)
{
    get_d1(self);
    if (simple_dat_p(dat))
        return INT2FIX(0);
    return m_fr(dat);
}

Gibt den Bruchteil des Tages im Bereich (Rational(0, 1)…Rational(1, 1)) zurück

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

deconstruct_keys(array_of_names_or_nil) → hash

Source

static VALUE
d_lite_deconstruct_keys(VALUE self, VALUE keys)
{
    return deconstruct_keys(self, keys, /* is_datetime=false */ 0);
}

Gibt einen Hash der Schlüssel-Wert-Paare zurück, zur Verwendung bei Mustervergleichen. Mögliche Schlüssel sind: :year, :month, :day, :wday, :yday.

Mögliche Verwendungen

d = Date.new(2022, 10, 5)

if d in wday: 3, day: ..7  # uses deconstruct_keys underneath
  puts "first Wednesday of the month"
end
#=> prints "first Wednesday of the month"

case d
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"

Beachten Sie, dass die Dekonstruktion per Muster auch mit Klassenprüfungen kombiniert werden kann.

if d in Date(wday: 3, day: ..7)
  puts "first Wednesday of the month"
end

downto(min){|date| ... } → self

Source

static VALUE
d_lite_downto(VALUE self, VALUE min)
{
    VALUE date;

    RETURN_ENUMERATOR(self, 1, &min);

    date = self;
    while (FIX2INT(d_lite_cmp(date, min)) >= 0) {
        rb_yield(date);
        date = d_lite_plus(date, INT2FIX(-1));
    }
    return self;
}

Entspricht step mit den Argumenten min und -1.

england → new_date

Source

static VALUE
d_lite_england(VALUE self)
{
    return dup_obj_with_new_start(self, ENGLAND);
}

Entspricht Date#new_start mit dem Argument Date::ENGLAND.

friday? → true oder false

Source

static VALUE
d_lite_friday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 5);
}

Gibt true zurück, wenn self ein Freitag ist, andernfalls false.

gregorian → new_date

Source

static VALUE
d_lite_gregorian(VALUE self)
{
    return dup_obj_with_new_start(self, GREGORIAN);
}

Entspricht Date#new_start mit dem Argument Date::GREGORIAN.

gregorian? → true oder false

Source

static VALUE
d_lite_gregorian_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_gregorian_p(dat));
}

Gibt true zurück, wenn das Datum am oder nach dem Datum der Kalenderreform liegt, andernfalls false

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

httpdate → string

Source

static VALUE
d_lite_httpdate(VALUE self)
{
    volatile VALUE dup = dup_obj_with_new_offset(self, 0);
    return strftimev("%a, %d %b %Y %T GMT", dup, set_tmx);
}

Entspricht strftime mit dem Argument '%a, %d %b %Y %T GMT'; siehe Formate für Daten und Zeiten

Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT"

infinite? → false

Source

# File ext/date/lib/date.rb, line 13
def infinite?
  false
end

Gibt false zurück

inspect → String

Source

static VALUE
d_lite_inspect(VALUE self)
{
    get_d1(self);
    return mk_inspect(dat, rb_obj_class(self), self);
}

Gibt eine String-Repräsentation von self zurück.

Date.new(2001, 2, 3).inspect
# => "#<Date: 2001-02-03 ((2451944j,0s,0n),+0s,2299161j)>"

iso8601 → string

Source

static VALUE
d_lite_iso8601(VALUE self)
{
    return strftimev("%Y-%m-%d", self, set_tmx);
}

Entspricht strftime mit dem Argument '%Y-%m-%d' (oder seiner Kurzform '%F');

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

Auch alias: xmlschema

italy → new_date

Source

static VALUE
d_lite_italy(VALUE self)
{
    return dup_obj_with_new_start(self, ITALY);
}

Entspricht Date#new_start mit dem Argument Date::ITALY.

jd → integer

Source

static VALUE
d_lite_jd(VALUE self)
{
    get_d1(self);
    return m_real_local_jd(dat);
}

Gibt die julianische Tagesnummer zurück. Dies ist eine ganze Zahl, die als lokale Zeit durch den Offset angepasst wird.

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

jisx0301 → string

Source

static VALUE
d_lite_jisx0301(VALUE self)
{
    char fmtbuf[JISX0301_DATE_SIZE];
    const char *fmt;

    get_d1(self);
    fmt = jisx0301_date_format(fmtbuf, sizeof(fmtbuf),
                               m_real_local_jd(dat),
                               m_real_year(dat));
    return strftimev(fmt, self, set_tmx);
}

Gibt eine String-Repräsentation des Datums in self im JIS X 0301 Format zurück.

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

julian → new_date

Source

static VALUE
d_lite_julian(VALUE self)
{
    return dup_obj_with_new_start(self, JULIAN);
}

Entspricht Date#new_start mit dem Argument Date::JULIAN.

julian? → true oder false

Source

static VALUE
d_lite_julian_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_julian_p(dat));
}

Gibt true zurück, wenn das Datum vor dem Datum der Kalenderreform liegt, andernfalls false

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

ld → integer

Source

static VALUE
d_lite_ld(VALUE self)
{
    get_d1(self);
    return f_sub(m_real_local_jd(dat), INT2FIX(2299160));
}

Gibt die Lilian-Tagesnummer zurück, was die Anzahl der Tage seit dem Beginn des gregorianischen Kalenders, 15. Oktober 1582, ist.

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

leap? → true oder false

Source

static VALUE
d_lite_leap_p(VALUE self)
{
    int rjd, ns, ry, rm, rd;

    get_d1(self);
    if (m_gregorian_p(dat))
        return f_boolcast(c_gregorian_leap_p(m_year(dat)));

    c_civil_to_jd(m_year(dat), 3, 1, m_virtual_sg(dat),
                  &rjd, &ns);
    c_jd_to_civil(rjd - 1, m_virtual_sg(dat), &ry, &rm, &rd);
    return f_boolcast(rd == 29);
}

Gibt true zurück, wenn das Jahr ein Schaltjahr ist, andernfalls false

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

mday → integer

Source

static VALUE
d_lite_mday(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_mday(dat));
}

Gibt den Tag des Monats im Bereich (1..31) zurück

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

Auch alias: day

mjd → integer

Source

static VALUE
d_lite_mjd(VALUE self)
{
    get_d1(self);
    return f_sub(m_real_local_jd(dat), INT2FIX(2400001));
}

Gibt die modifizierte julianische Tagesnummer zurück. Dies ist eine ganze Zahl, die als lokale Zeit durch den Offset angepasst wird.

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

mon → integer

Source

static VALUE
d_lite_mon(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_mon(dat));
}

Gibt den Monat im Bereich (1..12) zurück

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

Auch alias: month

monday? → true oder false

Source

static VALUE
d_lite_monday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 1);
}

Gibt true zurück, wenn self ein Montag ist, andernfalls false.

month

Alias für: mon

new_start(start = Date::ITALY]) → new_date

Source

static VALUE
d_lite_new_start(int argc, VALUE *argv, VALUE self)
{
    VALUE vsg;
    double sg;

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

    sg = DEFAULT_SG;
    if (argc >= 1)
        val2sg(vsg, sg);

    return dup_obj_with_new_start(self, sg);
}

Gibt eine Kopie von self mit dem angegebenen start-Wert zurück

d0 = Date.new(2000, 2, 3)
d0.julian? # => false
d1 = d0.new_start(Date::JULIAN)
d1.julian? # => true

Siehe Argument start.

next → new_date

Source

static VALUE
d_lite_next(VALUE self)
{
    return d_lite_next_day(0, (VALUE *)NULL, self);
}

Gibt ein neues Date-Objekt zurück, das dem folgenden Tag entspricht

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

Auch alias: succ

next_day(n = 1) → new_date

Source

static VALUE
d_lite_next_day(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
        n = INT2FIX(1);
    return d_lite_plus(self, n);
}

Entspricht Date#+ mit dem Argument n.

next_month(n = 1) → new_date

Source

static VALUE
d_lite_next_month(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
        n = INT2FIX(1);
    return d_lite_rshift(self, n);
}

Entspricht >> mit dem Argument n.

next_year(n = 1) → new_date

Source

static VALUE
d_lite_next_year(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
        n = INT2FIX(1);
    return d_lite_rshift(self, f_mul(n, INT2FIX(12)));
}

Entspricht >> mit dem Argument n * 12.

prev_day(n = 1) → new_date

Source

static VALUE
d_lite_prev_day(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
        n = INT2FIX(1);
    return d_lite_minus(self, n);
}

Entspricht Date#- mit dem Argument n.

prev_month(n = 1) → new_date

Source

static VALUE
d_lite_prev_month(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
        n = INT2FIX(1);
    return d_lite_lshift(self, n);
}

Entspricht << mit dem Argument n.

prev_year(n = 1) → new_date

Source

static VALUE
d_lite_prev_year(int argc, VALUE *argv, VALUE self)
{
    VALUE n;

    rb_scan_args(argc, argv, "01", &n);
    if (argc < 1)
        n = INT2FIX(1);
    return d_lite_lshift(self, f_mul(n, INT2FIX(12)));
}

Entspricht << mit dem Argument n * 12.

rfc2822 → string

Source

static VALUE
d_lite_rfc2822(VALUE self)
{
    return strftimev("%a, %-d %b %Y %T %z", self, set_tmx);
}

Entspricht strftime mit dem Argument '%a, %-d %b %Y %T %z'; siehe Formate für Daten und Zeiten

Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000"

Auch alias: rfc822, rfc822

rfc3339 → string

Source

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

Entspricht strftime mit dem Argument '%FT%T%:z'; siehe Formate für Daten und Zeiten

Date.new(2001, 2, 3).rfc3339 # => "2001-02-03T00:00:00+00:00"

rfc822

Alias für: rfc2822

saturday? → true oder false

Source

static VALUE
d_lite_saturday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 6);
}

Gibt true zurück, wenn self ein Samstag ist, andernfalls false.

start → float

Source

static VALUE
d_lite_start(VALUE self)
{
    get_d1(self);
    return DBL2NUM(m_sg(dat));
}

Gibt das julianische Startdatum für die Kalenderreform zurück; wenn es keine Unendlichkeit ist, ist der zurückgegebene Wert für die Übergabe an Date#jd geeignet

d = Date.new(2001, 2, 3, Date::ITALY)
s = d.start     # => 2299161.0
Date.jd(s).to_s # => "1582-10-15"

d = Date.new(2001, 2, 3, Date::ENGLAND)
s = d.start     # => 2361222.0
Date.jd(s).to_s # => "1752-09-14"

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

Siehe Argument start.

step(limit, step = 1){|date| ... } → self

Source

static VALUE
d_lite_step(int argc, VALUE *argv, VALUE self)
{
    VALUE limit, step, date;
    int c;

    rb_scan_args(argc, argv, "11", &limit, &step);

    if (argc < 2)
        step = INT2FIX(1);

#if 0
    if (f_zero_p(step))
        rb_raise(rb_eArgError, "step can't be 0");
#endif

    RETURN_ENUMERATOR(self, argc, argv);

    date = self;
    c = f_cmp(step, INT2FIX(0));
    if (c < 0) {
        while (FIX2INT(d_lite_cmp(date, limit)) >= 0) {
            rb_yield(date);
            date = d_lite_plus(date, step);
        }
    }
    else if (c == 0) {
        while (1)
            rb_yield(date);
    }
    else /* if (c > 0) */ {
        while (FIX2INT(d_lite_cmp(date, limit)) <= 0) {
            rb_yield(date);
            date = d_lite_plus(date, step);
        }
    }
    return self;
}

Ruft den Block mit angegebenen Daten auf; gibt self zurück.

Das erste date ist self.
Jedes aufeinanderfolgende date ist date + step, wobei step die numerische Schrittweite in Tagen ist.
Das letzte Datum ist das letzte, das vor oder gleich limit ist, welches ein Date-Objekt sein sollte.

Beispiel

limit = Date.new(2001, 12, 31)
Date.new(2001).step(limit){|date| p date.to_s if date.mday == 31 }

Ausgabe

"2001-01-31"
"2001-03-31"
"2001-05-31"
"2001-07-31"
"2001-08-31"
"2001-10-31"
"2001-12-31"

Gibt einen Enumerator zurück, wenn kein Block gegeben ist.

strftime(format = '%F') → string

Source

static VALUE
d_lite_strftime(int argc, VALUE *argv, VALUE self)
{
    return date_strftime_internal(argc, argv, self,
                                  "%Y-%m-%d", set_tmx);
}

Gibt eine String-Repräsentation des Datums in self zurück, formatiert gemäß dem angegebenen format

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

Für andere Formate siehe Formate für Daten und Zeiten.

succ

Alias für: next

sunday? → true oder false

Source

static VALUE
d_lite_sunday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 0);
}

Gibt true zurück, wenn self ein Sonntag ist, andernfalls false.

thursday? → true oder false

Source

static VALUE
d_lite_thursday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 4);
}

Gibt true zurück, wenn self ein Donnerstag ist, andernfalls false.

to_date → self

Source

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

Gibt self zurück.

to_datetime → datetime

Source

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

    if (simple_dat_p(adat)) {
        VALUE new = d_lite_s_alloc_simple(cDateTime);
        {
            get_d1b(new);
            bdat->s = adat->s;
            return new;
        }
    }
    else {
        VALUE new = d_lite_s_alloc_complex(cDateTime);
        {
            get_d1b(new);
            bdat->c = adat->c;
            bdat->c.df = 0;
            RB_OBJ_WRITE(new, &bdat->c.sf, INT2FIX(0));
#ifndef USE_PACK
            bdat->c.hour = 0;
            bdat->c.min = 0;
            bdat->c.sec = 0;
#else
            bdat->c.pc = PACK5(EX_MON(adat->c.pc), EX_MDAY(adat->c.pc),
                               0, 0, 0);
            bdat->c.flags |= HAVE_DF | HAVE_TIME;
#endif
            return new;
        }
    }
}

Gibt ein DateTime zurück, dessen Wert derselbe ist wie self

Date.new(2001, 2, 3).to_datetime # => #<DateTime: 2001-02-03T00:00:00+00:00>

to_json (*args)

Source

# File ext/json/lib/json/add/date.rb, line 51
def to_json(*args)
  as_json.to_json(*args)
end

Gibt einen JSON-String zurück, der self repräsentiert

require 'json/add/date'
puts Date.today.to_json

Ausgabe

{"json_class":"Date","y":2023,"m":11,"d":21,"sg":2299161.0}

to_s → String

Source

static VALUE
d_lite_to_s(VALUE self)
{
    return strftimev("%Y-%m-%d", self, set_tmx);
}

Gibt eine String-Repräsentation des Datums in self im ISO 8601 erweiterten Datumsformat ('%Y-%m-%d') zurück

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

to_time → time

Source

static VALUE
date_to_time(VALUE self)
{
    VALUE t;

    get_d1a(self);

    if (m_julian_p(adat)) {
        VALUE g = d_lite_gregorian(self);
        get_d1b(g);
        adat = bdat;
        self = g;
    }

    t = f_local3(rb_cTime,
        m_real_year(adat),
        INT2FIX(m_mon(adat)),
        INT2FIX(m_mday(adat)));
    RB_GC_GUARD(self); /* may be the converted gregorian */
    return t;
}

Gibt ein neues Time-Objekt mit demselben Wert wie self zurück; wenn self ein julianisches Datum ist, leitet es sein gregorianisches Datum für die Konvertierung in das Time-Objekt ab

Date.new(2001, 2, 3).to_time               # => 2001-02-03 00:00:00 -0600
Date.new(2001, 2, 3, Date::JULIAN).to_time # => 2001-02-16 00:00:00 -0600

tuesday? → true oder false

Source

static VALUE
d_lite_tuesday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 2);
}

Gibt true zurück, wenn self ein Dienstag ist, andernfalls false.

upto(max){|date| ... } → self

Source

static VALUE
d_lite_upto(VALUE self, VALUE max)
{
    VALUE date;

    RETURN_ENUMERATOR(self, 1, &max);

    date = self;
    while (FIX2INT(d_lite_cmp(date, max)) <= 0) {
        rb_yield(date);
        date = d_lite_plus(date, INT2FIX(1));
    }
    return self;
}

Entspricht step mit den Argumenten max und 1.

wday → integer

Source

static VALUE
d_lite_wday(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_wday(dat));
}

Gibt den Wochentag im Bereich (0..6) zurück; Sonntag ist 0

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

wednesday? → true oder false

Source

static VALUE
d_lite_wednesday_p(VALUE self)
{
    get_d1(self);
    return f_boolcast(m_wday(dat) == 3);
}

Gibt true zurück, wenn self ein Mittwoch ist, andernfalls false.

xmlschema

Alias für: iso8601

yday → integer

Source

static VALUE
d_lite_yday(VALUE self)
{
    get_d1(self);
    return INT2FIX(m_yday(dat));
}

Gibt den Tag des Jahres im Bereich (1..366) zurück

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

year → integer

Source

static VALUE
d_lite_year(VALUE self)
{
    get_d1(self);
    return m_real_year(dat);
}

Gibt das Jahr zurück

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