Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
Class::Date(3)	      User Contributed Perl Documentation	Class::Date(3)

       Class::Date - Class for easy date and time manipulation

       version 1.1.17

	 use Class::Date qw(:errors date localdate gmdate now -DateParse -EnvC);

	 # creating absolute date object (local	time)
	 $date = Class::Date->new( [$year,$month,$day,$hour,$min,$sec]);
	 $date = date [$year,$month,$day,$hour,$min,$sec];
	   # ^-	"date" is an exportable	function, the same as Class::Date->new
	 $date = date {	year =>	$year, month =>	$month,	day => $day,
	   hour	=> $hour, min => $min, sec => $sec };
	 $date = date "2001-11-12 07:13:12";
	 $date = localdate "2001-12-11";
	 $date = now;			   #  the same as date(time)
	 $date = date($other_date_object); # cloning

	 # creating absolute date object (GMT)
	 $date = Class::Date->new( [$year,$month,$day,$hour,$min,$sec],'GMT');
	 $date = gmdate	"2001-11-12 17:13";

	 # creating absolute date object in any	other timezone
	 $date = Class::Date->new( [$year,$month,$day,$hour,$min,$sec],'Iceland' );
	 $date = date "2001-11-12 17:13", 'Iceland';
	 $date2	= $date->new([$y2, $m2,	$d2, $h2, $m2, $s2]);
	   # ^-	timezone is inherited from the $date object

	 # creating relative date object
	 # (normally you don't need to create this object explicitly)
	 $reldate = Class::Date::Rel->new( "3Y 1M 3D 6h	2m 4s" );
	 $reldate = Class::Date::Rel->new( "6Y"	);
	 $reldate = Class::Date::Rel->new( $secs );  # secs
	 $reldate = Class::Date::Rel->new( [$year,$month,$day,$hour,$min,$sec] );
	 $reldate = Class::Date::Rel->new( { year => $year, month => $month, day => $day,
	   hour	=> $hour, min => $min, sec => $sec } );
	 $reldate = Class::Date::Rel->new( "2001-11-12 07:13:12" );
	 $reldate = Class::Date::Rel->new( "2001-12-11"	);

	 # getting values of an	absolute date object
	 $date;		     # prints the date in default output format	(see below)
	 $date->year;	     # year, e.g: 2001
	 $date->_year;	     # year - 1900, e.g. 101
	 $date->yr;	     # 2-digit year 0-99, e.g 1
	 $date->mon;	     # month 1..12
	 $date->month;	     # same as prev.
	 $date->_mon;	     # month 0..11
	 $date->_month;	     # same as prev.
	 $date->day;	     # day of month
	 $date->mday;	     # day of month
	 $date->day_of_month;# same as prev.
	 $date->minute;	     # same as prev.
	 $date->second;	     # same as prev.
	 $date->wday;	     # 1 = Sunday
	 $date->_wday;	     # 0 = Sunday
	 $date->day_of_week; # same as prev.
	 $date->day_of_year; # same as prev.
	 $date->isdst;	     # DST?
	 $date->daylight_savings; # same as prev.
	 $date->epoch;	     # UNIX time_t
	 $date->monname;     # name of month, eg: March
	 $date->monthname;   # same as prev.
	 $date->wdayname;    # Thursday
	 $date->day_of_weekname	# same as prev.
	 $date->hms	     # 01:23:45
	 $date->ymd	     # 2000/02/29
	 $date->mdy	     # 02/29/2000
	 $date->dmy	     # 29/02/2000
	 $date->meridiam     # 01:23 AM
	 $date->ampm	     # AM/PM
	 $date->string	     # 2000-02-29 12:21:11 (format can be changed, look	below)
	 "$date"	     # same as prev.
	 $date->tzoffset     # timezone-offset
	 $date->strftime($format) # POSIX strftime (without the	huge
	 $date->tz	     # returns the base	timezone as you	specify, eg: CET
	 $date->tzdst	     # returns the real	timezone with dst information, eg: CEST

	 ($year,$month,$day,$hour,$min,$sec)=@{	$date->aref };
	 # !! $year: 1900-, $month: 1-12

	 ($sec,$min,$hour,$day,$mon,$year,$wday,$yday,$isdst)=@{ $date->sref };
	 # !! $year: 0-, $month: 0-11

	 $hash=$date->href; # $href can	be reused as a constructor
	 print $hash->{year}."-".$hash->{month}. ... $hash->{sec} ... ;

	 # !! $hash{year}: 1900-, $hash{month}:	1-12

	 $date->month_begin  # First day of the	month (date object)
	 $date->month_end    # Last day	of the month
	 $date->days_in_month #	28..31

	 # constructing	new date based on an existing one:
	 $new_date = $date->clone;
	 $new_date = $date->clone( year	=> 1977, sec =>	14 );
	 # valid keys: year, _year, month, mon,	_month,	_mon, day, mday, day_of_month,
	 #	       hour, min, minute, sec, second, tz
	 # constructing	a new date, which is the same as the original, but in
	 # another timezone:
	 $new_date = $date->to_tz('Iceland');

	 # changing date format
	   local $Class::Date::DATE_FORMAT="%Y%m%d%H%M%S";
	   print $date	     # result: 20011222000000
	   print $date	     # result: Thu Oct 13 04:54:34 1994
	   print $date	     # result: 1994/10/13

	 # error handling
	 $a = date($date_string);
	 if ($a) { # valid date
	 } else	{ # invalid date
	   if ($a->error == E_INVALID) { ... }
	   print $a->errstr;

	 # adjusting DST in calculations  (see the doc)
	 $Class::Date::DST_ADJUST = 1; # this is the default
	 $Class::Date::DST_ADJUST = 0;

	 # "month-border adjust" flag
	 $Class::Date::MONTH_BORDER_ADJUST = 0;	# this is the default
	 print date("2001-01-31")+'1M';	# will print 2001-03-03
	 $Class::Date::MONTH_BORDER_ADJUST = 1;
	 print date("2001-01-31")+'1M';	# will print 2001-02-28

	 # date	range check
	 $Class::Date::RANGE_CHECK = 0;	# this is the default
	 print date("2001-02-31"); # will print	2001-03-03
	 $Class::Date::RANGE_CHECK = 1;
	 print date("2001-02-31"); # will print	nothing

	 # getting values of a relative	date object
	 $reldate;		# reldate in seconds (assumed 1	month =	2_629_744 secs)
	 $reldate->month;	# same as prev.
	 $reldate->minute;	# same as prev.
	 $reldate->sec;		# same as $reldate
	 $reldate->second;	# same as prev.
	 $reldate->sec_part;	# "second" part	of the relative	date
	 $reldate->mon_part;	# "month"  part	of the relative	date

	 # arithmetic with dates:
	 print date([2001,12,11,4,5,6])->truncate;
				      #	will print "2001-12-11"
	 $new_date = $date+$reldate;
	 $date2	   = $date+'3Y 2D';   #	3 Years	and 2 days
	 $date3	   = $date+[1,2,3];   #	$date plus 1 year, 2 months, 3 days
	 $date4	   = $date+'3-1-5'    #	$date plus 3 years, 1 months, 5	days

	 $new_date = $date-$reldate;
	 $date2	   = $date-'3Y';      #	3 Yearss
	 $date3	   = $date-[1,2,3];   #	$date minus 1 year, 2 months, 3	days
	 $date4	   = $date-'3-1-5'    #	$date minus 3 years, 1 month, 5	days

	 $new_reldate =	$date1-$date2;
	 $reldate2 = Class::Date->new('2000-11-12')-'2000-11-10';
	 $reldate3    =	$date3-'1977-11-10';

	 $days_between = (Class::Date->new('2001-11-12')-'2001-07-04')->day;

	 # comparison between absolute dates
	 print $date1 >	$date2 ? "I am older" :	"I am younger";

	 # comparison between relative dates
	 print $reldate1 > $reldate2 ? "I am faster" : "I am slower";

	 # Adding / Subtracting	months and years are sometimes tricky:
	 print date("2001-01-29") + '1M' - '1M'; # gives "2001-02-01"
	 print date("2000-02-29") + '1Y' - '1Y'; # gives "2000-03-01"

	 # Named interface ($date2 does	not necessary to be a Class::Date object)
	 $date1->string;	       # same as $date1	in scalar context
	 $date1->subtract($date2);     # same as $date1	- $date2
	 $date1->add($date2);	       # same as $date1	+ $date2
	 $date1->compare($date2);      # same as $date1	<=> $date2

	 $reldate1->sec;	       # same as $reldate1 in numeric or scalar	context
	 $reldate1->compare($reldate2);# same as $reldate1 <=> $reldate2
	 $reldate1->add($reldate2);    # same as $reldate1 + $reldate2
	 $reldate1->neg		       # used for subtraction

	 # Disabling Class::Date warnings at load time
	 BEGIN { $Class::Date::WARNINGS=0; }
	 use Class::Date;

       This module is intended to provide a general-purpose date and datetime
       type for	perl. You have a Class::Date class for absolute	date and
       datetime, and have a Class::Date::Rel class for relative	dates.

       You can use "+",	"-", "<" and ">" operators as with native perl data

       Note that this module is	fairly ancient and dusty. You might want to
       take a look at DateTime and its related modules for a more standard,
       and maintained, Perl date manipulation solution.

       If you want to use a date object, you need to do	the following:

	 - create a new	object
	 - do some operations (+, -, comparison)
	 - get result back

   Creating a new date object
       You can create a	date object by the "date", "localdate" or "gmdate"
       function, or by calling the Class::Date constructor.

       "date" and "Class::Date->new" are equivalent, both has two arguments:
       The date	and the	timezone.

	 $date1= date [2000,11,12];
	 $date2= Class::Date->new([2000,06,11,13,11,22],'GMT');
	 $date2= $date1->new([2000,06,11,13,11,22]);

       If the timezone information is omitted, then it first check if "new" is
       called as an object method or a class method. If	it is an object
       method, then it inherits	the timezone from the base object, otherwise
       the default timezone is used ($Class::Date::DEFAULT_TIMEZONE), which is
       usually set to the local	timezone (which	is stored in
       $Class::Date::LOCAL_TIMEZONE). These two	variables are set only once to
       the value, which	is returned by the Class::Date::local_timezone()
       function. You can change	these values whenever you want.

       "localdate $x" is equivalent to "date $x,
       $Class::Date::LOCAL_TIMEZONE", "gmdate $x" is equivalent	to "date $x,

       $Class::Date::GMT_TIMEZONE is set to 'GMT' by default.

	 $date1= localdate [2000,11,12];
	 $date2= gmdate	[2000,4,2,3,33,33];

	 $date = localdate(time);

       The format of the accepted input	date can be:

	   An array reference with 6 elements. The missing elements have
	   default values (year: 2000, month, day: 1, hour, min, sec: 0)

       { year => $year,	month => $month, day =>	$day, hour => $hour, min =>
       $min, sec => $sec }
	   A hash reference with the same 6 elements as	above.

	   A mysql-style timestamp value, which	consist	of at least 14 digit.

	   A valid 32-bit integer: This	is parsed as a unix time.

       "YYYY-MM-DD hh:mm:ss"
	   A standard ISO(-like) date format. Additional ".fraction" part is
	   ignored, ":ss" can be omitted.

       additional input	formats
	   You can specify "-DateParse"	as  an import parameter, e.g:

	     use Class::Date qw(date -DateParse);

	   With	this, the module will try to load Date::Parse module, and if
	   it find it then all these formats can be used as an input. Please
	   refer to the	Date::Parse documentation.

	   You can add the following to	a Class::Date object:

	     - a valid Class::Date::Rel	object
	     - anything, that can be used for creating a new Class::Date::Rel object

	   It means that you don't need	to create a new	Class::Date::Rel
	   object every	time when you add something to the Class::Date object,
	   it creates them automatically:

	     $date= Class::Date->new('2001-12-11')+Class::Date::Rel->new('3Y');

	   is the same as:

	     $date= date('2001-12-11')+'3Y';

	   You can provide a Class::Date::Rel object in	the following form:

	   array ref
	       The same	format as seen in Class::Date format, except the
	       default values are different: all zero.

	   hash	ref
	       The same	format as seen in Class::Date format, except the
	       default values are different: all zero.

	       A valid 32-bit integer is parsed	as seconds.

	   "YYYY-MM-DD hh:mm:ss"
	       A standard ISO date format, but this is parsed as relative date
	       date and	time, so month,	day and	year can be zero (and defaults
	       to zero).

	   "12Y	6M 6D 20h 12m 5s"
	       This special string can be used if you don't want to use	the
	       ISO format. This	string consists	of whitespace separated	tags,
	       each tag	consists of a number and a unit. The units can be:

		 Y: year
		 M: month
		 D: day
		 h: hour
		 m: min
		 s: sec

	       The number and unit must	be written with	no space between them.

	   The same rules are true for substraction, except you	can substract
	   two Class::Date object from each other, and you will	get a
	   Class::Date::Rel object:

	     $reldate=date('2001-11-12 12:11:07')-date('2001-10-07 10:3:21');

	   In this case, the "month" field of the $reldate object will be 0,
	   and the other fields	will contain the difference between two	dates;

	   You can compare two Class::Date objects, or one Class::Date object
	   and another data, which can be used for creating a new Class::Data

	   It means that you don't need	to bless both objects, one of them can
	   be a	simple string, array ref, hash ref, etc	(see how to create a
	   date	object).

	     if	( date('2001-11-12') > date('2000-11-11') ) { ... }


	     if	( date('2001-11-12') > '2000-11-11' ) {	... }

	   You can chop	the time value from this object	(set hour, min and sec
	   to 0) with the "truncate" or	"trunc"	method.	It does	not modify the
	   specified object, it	returns	with a new one.

	   You can create new date object based	on an existing one, by using
	   the "clone" method. Note, this DOES NOT modify the base object.

	     $new_date = $date->clone( year => 2001, hour => 14	);

	   The valid keys are: year, _year, month, mon,	_month,	_mon, day,
	   mday, day_of_month, hour, min, minute, sec, second, tz.

	   There is a "set" method, which does the same	as the "clone",	it
	   exists only for compatibility.

	   You can use "to_tz" to create a new object, which means the same
	   time	as the base object, but	in the different timezone.

	   Note	that $date->clone( tz => 'Iceland') and
	   $date->to_tz('Iceland') is not the same! Cloning a new object with
	   setting timezone will preserve the time information (hour, minute,
	   second, etc.), but transfer the time	into other timezone, while
	   to_tz usually change	these values based on the difference between
	   the source and the destination timezone.

       Operations with Class::Date::Rel
	   The Class::Date::Rel	object consists	of a month part	and a day
	   part. Most people only use the "day"	part of	it. If you use both
	   part, then you can get these	parts with the "sec_part" and
	   "mon_part" method. If you use "sec",	"month", etc. methods or if
	   you use this	object in a mathematical context, then this object is
	   converted to	one number, which is interpreted as second.  The
	   conversion is based on a 30.436 days	month. Don't use it too	often,
	   because it is confusing...

	   If you use Class::Date::Rel in an expression	with other Class::Date
	   or Class::Date::Rel objects,	then it	does what is expected:

	     date('2001-11-12')+'1M' will be '2001-12-12'


	     date('1996-02-11')+'2M' will be '1996-04-11'

   Accessing data from a Class::Date and Class::Date::Rel object
       You can use the methods methods described at the	top of the document if
       you want	to access parts	of the data which is stored in a Class::Date
       and Class::Date::Rel object.

   Error handling
       If a date object	became invalid,	then the object	will be	reblessed to
       Class::Date::Invalid. This object is false in boolean environment, so
       you can test the	date validity like this:

	 $a = date($input_date);
	 if ($a) { # valid date
	 } else	{ # invalid date
	     if	($a->error == E_INVALID) { ... }
	     print $a->errstr;

       Note even the date is invalid, the expression "defined $a" always
       returns true, so	the following is wrong:

	 $a = date($input_date);
	 if (defined $a) ... # WRONG!!!!

       You can test the	error by getting the $date->error value. You might
       import the ":errors" tag:

	 use Class::Date qw(:errors);

       Possible	error values are:

	   No errors.

	   Invalid date. It is set when	some of	the parts of the date are
	   invalid, and	Time::Local functions cannot convert them to a valid

	   This	error is set, when parts of the	date are valid,	but the	whole
	   date	is not valid, e.g. 2001-02-31. When the
	   $Class::Date::RANGE_CHECK is	not set, then these date values	are
	   automatically converted to a	valid date: 2001-03-03,	but the
	   $date->error	value are set to E_RANGE. If $Class::Date::RANGE_CHECK
	   is set, then	a date "2001-02-31" became invalid date.

	   This	error is set, when the constructor cannot be created from a
	   scalar, e.g:

	     $a	= date("4kd sdlsdf lwekrmk");

	   This	error is set, when you want to create a	date object from an
	   undefined value:

	     $a	= Class::Date->new(undef);

	   Note, that localdate(undef) will create a valid object, because it
	   calls $Class::Date(time).

       You can get the error in	string form by calling the "errstr" method.

       $DST_ADJUST is an important configuration option.

       If it is	set to true (default), then the	module adjusts the date	and
       time when the operation switches	the border of DST. With	this setting,
       you are ignoring	the effect of DST.

       When $DST_ADJUST	is set to false, then no adjustment is done, the
       calculation will	be based on the	exact time difference.

       You will	see the	difference through an example:


	 print date("2000-10-29", "CET") + "1D";
	 # This	will print 2000-10-30 00:00:00

	 print date("2001-03-24	23:00:00", "CET") + "1D";
	 # This	will be	2001-03-25 23:00:00

	 print date("2001-03-25", "CET") + "1D";
	 # This	will be	2001-03-26 00:00:00


	 print date("2000-10-29", "CET") + "1D";
	 # This	will print 2000-10-29 23:00:00

	 print date("2001-03-24	23:00:00", "CET") + "1D";
	 # This	will be	2001-03-26 00:00:00

       If you add or subtract "months" and "years" to a	date, you may get
       wrong dates, e.g	when you add one month to 2001-01-31, you expect to
       get 2001-02-31, but this	date is	invalid	and converted to 2001-03-03.
       Thats' why

	 date("2001-01-31") + '1M' - '1M' != "2001-01-31"

       This problem can	occur only with	months and years, because others can
       easily be converted to seconds.

       $MONTH_BORDER_ADJUST variable is	used to	switch on or off the month-
       adjust feature. This is used only when someone adds months or years to
       a date and then the resulted date became	invalid. An example: adding
       one month to "2001-01-31" will result "2001-02-31", and this is an
       invalid date.

       When $MONTH_BORDER_ADJUST is false, this	result simply normalized, and
       becomes "2001-03-03". This is the default behaviour.

       When $MONTH_BORDER_ADJUST is true, this result becomes "2001-02-28". So
       when the	date overflows,	then it	returns	the last day insted.

       Both settings keep the time information.

       Since 1.0.11, Class::Date handle	timezones natively on most platforms
       (see the	BUGS AND LIMITATIONS section for more info).

       When the	module is loaded, then it determines the local base timezone
       by calling the Class::Date::local_timezone() function, and stores these
       values into two variables, these	are: $Class::Date::LOCAL_TIMEZONE and
       $Class::Date::DEFAULT_TIMEZONE. The first value is used,	when you call
       the "localdate" function, the second value is used, when	you call the
       "date" function and you don't specify the timezone. There is a
       $Class::Date::GMT_TIMEZONE function also, which is used by the "gmdate"
       function, this is set to	'GMT'.

       You can query the timezone of a date object by calling the $date->tz
       method. Note this value returns the timezone as you specify, so if you
       create the object with an unknown timezone, you will get	this back. If
       you want	to query the effective timezone, you can call the $date->tzdst
       method.	This method returns only valid timezones, but it is not
       necessarily the timezone	which can be used to create a new object. For
       example $date->tzdst can	return 'CEST', which is	not a valid base
       timezone, because it contains daylight savings information also.	On
       Linux systems, you can see the possible base timezones in the
       /usr/share/zoneinfo directory.

       In Class::Date 1.1.6, a new environment variable	is introduced:
       $Class::Date::NOTZ_TIMEZONE. This variable stores the local timezone,
       which is	used, when the TZ environment variable is not set. It is
       introduced, because there are some systems, which cannot	handle the
       queried timezone	well. For example the local timezone is	CST, it	is
       returned	by the tzname()	perl function, but when	I set the TZ
       environment variable to CST, it works like it would be GMT.  The
       workaround is NOTZ_TIMEZONE: if a date object has a timezone, which is
       the same	as NOTZ_TIMEZONE, then the TZ variable will be removed before
       each calculation. In normal case, it would be the same as setting TZ to
       $NOTZ_TIMEZONE, but some	systems	don't like it, so I decided to
       introduce this variable.	The $Class::Date::NOTZ_TIMEZONE	variable is
       set in the initialization of the	module by removing the TZ variable
       from the	environment and	querying the tzname variable.

       This module uses	operator overloading very heavily. I've	found it quite
       stable, but I am	afraid of it a bit.

       A Class::Date object is an array	reference.

       A Class::Date::Rel object is an array reference,	which contains month
       and second information. I need to store it as an	array ref, because
       array and month values cannot be	converted into seconds,	because	of our
       super calendar.

       You can add code	references to the @Class::Date::NEW_FROM_SCALAR	and
       @Class::Date::Rel::NEW_FROM_SCALAR. These arrays	are iterated through
       when a scalar-format date must be parsed. These arrays only have	one or
       two values at initialization. The parameters which the code references
       got are the same	as the "new" method of each class. In this way,	you
       can personalize the date	parses as you want.

       As of 0.90, the Class::Date has been rewritten. A lot of	code and
       design decision has been	borrowed from Matt Sergeant's Time::Object,
       and there will be some incompatibility with the previous	public version
       (0.5). I	tried to keep compatibility methods in Class::Date. If you
       have problems regarding this, please drop me an email with the
       description of the problem, and I will set the compatibility back.

       Invalid dates are Class::Date::Invalid objects. Every method call on
       this object and every operation with this object	returns	undef or 0.

       This module tries to be as full-featured	as can be. It currently	lacks
       business-day calculation, which is planned to be	implemented in the
       1.0.x series.

       I try to	keep this module not to	depend on other	modules	and I want
       this module usable without a C compiler.

       Currently the module uses the POSIX localtime function very
       extensively.  This makes	the date calculation a bit slow, but provides
       a rich interface, which is not provided by any other module. When I
       tried to	redesign the internals to not depend on	localtime, I failed,
       because there are no other way to determine the daylight	savings

       There are two kind of adjustment	in this	module,	DST_ADJUST and
       MONTH_BORDER_ADJUST. Both of them makes the "+" and "-" operations
       slower. If you don't need them, switch them off to achieve faster

       In general, if you really need fast date	and datetime calculation,
       don't use this module. As you see in the	previous section, the focus of
       development is not the speed in 1.0.  For fast date and datetime
       calculations, use Date::Calc module instead.

       This module is NOT thread-safe, since it	uses C library functions,
       which are not thread-safe. Using	this module in a multi-threaded
       environment can cause timezones to be messed up.	I did not put any
       warning about it, you have to make sure that you	understand this!

       Under some circumstances	in a mod_perl environment, you require the
       Env::C module to	set the	TZ variable properly before calling the	time
       functions. I added the -EnvC import option to automatically load	this
       module if it is not loaded already. Please read the mod_perl
       documentation about the environment variables and mod_perl to get the
       idea why	it is required sometimes:

       You are sure have this problem if the $Class::Date::NOTZ_TIMEZONE
       variable	is set to 'UTC', althought you are sure	that your timezone is
       not that. Try -EnvC in this case, but make sure that you	are not	using
       it in a multi-threaded environment!

       o   Not all date/time values can	be expressed in	all timezones. For

	     print date("2010-10-03 02:00:00", "Australia/Sydney")
	     # it will print 2010-10-03	03:00:00

	   No matter how hard you try you, you are not going to	be able	to
	   express the time in the example in that timezone. If	you don't need
	   the timezone	information and	you want to make sure that the
	   calculations	are always correct, please use GMT as a	timezone (the
	   'gmdate' function can be a shortcut for it).	In this	case, you
	   might also consider turning off DST_ADJUST to speed up the

       o   I cannot manage to get the timezone code working properly on
	   ActivePerl 5.8.0 on win XP and earlier versions possibly have this
	   problem also. If you	have a system like this, then you will have
	   only	two timezones, the local and the GMT. Every timezone, which is
	   not equal to	$Class::Date::GMT_TIMEZONE is assumed to be local.
	   This	seems to be caused by the win32	implementation of timezone
	   routines. I don't really know how to	make this thing	working, so I
	   gave	up this	issue. If anyone know a	working	solution, then I will
	   integrate it	into Class::Date, but until then, the timezone support
	   will	not be available for these platforms.

       o   Perl	5.8.0 and earlier versions has a bug in	the strftime code on
	   some	operating systems (for example Linux), which is	timezone
	   related. I recommend	using the strftime, which is provided with
	   Class::Date,	so don't try to	use the	module without the compiled
	   part. The module will not work with a buggy strftime	- the test is
	   hardcoded into the beginning	of the code. If	you anyway want	to use
	   the module, remove the hardcoded "die" from the module, but do it
	   for your own	risk.

       o   This	module uses the	POSIX functions	for date and time
	   calculations, so it is not working for dates	beyond 2038 and	before

	   I don't know	what systems support dates in 1902-1970	range, it may
	   not work on your system. I know it works on the Linux glibc system
	   with	perl 5.6.1 and 5.7.2. I	know it	does not work with perl
	   5.005_03 (it	may be the bug of the Time::Local module). Please
	   report if you know any system where it does _not_ work with perl
	   5.6.1 or later.

	   I hope that someone will fix	this with new time_t in	libc. If you
	   really need dates over 2038 and before 1902,	you need to completely
	   rewrite this	module or use Date::Calc or other date modules.

       o   This	module uses Time::Local, and when it croaks, Class::Date
	   returns "Invalid date or time" error	message. Time::Local is
	   different in	the 5.005 and 5.6.x (and even 5.7.x) version of	perl,
	   so the following code will return different results:

	     $a	= date("2006-11-11")->clone(year => -1);

	   In perl 5.6.1, it returns an	invalid	date with error	message
	   "Invali date	or time", in perl 5.005	it returns an invalid date
	   with	range check error. Both	are false if you use them in boolean
	   context though, only	the error message is different,	but don't rely
	   on the error	message	in this	case. It however works in the same way
	   if you change other fields than "year" to an	invalid	field.

       Class::Date is free software. IT	COMES WITHOUT WARRANTY OF ANY KIND.

       If you have questions, you can send questions directly to me:

WIN32 notes
       You can get a binary win32 version of Class::Date from Chris Winters'
       .ppd repository with the	following commands:

       For people using	PPM2:

	 c:\> ppm
	 PPM> set repository oi
	 PPM> set save
	 PPM> install Class-Date

       For people using	PPM3:

	 c:\> ppm
	 PPM> repository
	 PPM> install Class-Date

       The first steps in PPM only needs to be done at the first time. Next
       time you	just run the 'install'.

       Copyright (c) 2001 SzabA^3, BalA!zs (dLux)

       All rights reserved. This program is free software; you can
       redistribute it and/or modify it	under the same terms as	Perl itself.

       Portions	Copyright (c) Matt Sergeant

	 - Matt	Sergeant <>
	   (Lots of code are borrowed from the Time::Object module)
	 - Tatsuhiko Miyagawa <> (bugfixes)
	 - Stas	Bekman <> (suggestions, bugfix)
	 - Chris Winters <> (win32 .ppd version)
	 - Benoit Beausejour <>
	   (Parts of the timezone code is borrowed from	his Date::Handler module)

       perl(1).	 Date::Calc(3pm).  Time::Object(3pm).  Date::Handler(3pm).

       o   dLux	(SzabA^3, BalA!zs) <>

       o   Gabor Szabo <>

       o   Yanick Champoux <>

       This software is	copyright (c) 2018, 2014, 2010,	2003 by	BalA!zs

       This is free software; you can redistribute it and/or modify it under
       the same	terms as the Perl 5 programming	language system	itself.

perl v5.32.1			  2018-06-01			Class::Date(3)


Want to link to this manual page? Use this URL:

home | help