You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
779 lines
27 KiB
779 lines
27 KiB
/**
|
|
* @class Date
|
|
*
|
|
* The date parsing and format syntax is a subset of
|
|
* <a href="http://www.php.net/date">PHP's date() function</a>, and the formats that are
|
|
* supported will provide results equivalent to their PHP versions.
|
|
*
|
|
* Following is the list of all currently supported formats:
|
|
*<pre>
|
|
Format Description Example returned values
|
|
------ ---------------------------------------------------------------------- -----------------------
|
|
d Day of the month, 2 digits with leading zeros 01 to 31
|
|
D A textual representation of a day, three letters Mon to Sun
|
|
j Day of the month without leading zeros 1 to 31
|
|
l A full textual representation of the day of the week Sunday to Saturday
|
|
S English ordinal suffix for the day of the month, 2 characters st, nd, rd or th. Works well with j
|
|
w Numeric representation of the day of the week 0 (for Sunday) to 6 (for Saturday)
|
|
z The day of the year (starting from 0) 0 to 364 (365 in leap years)
|
|
W ISO-8601 week number of year, weeks starting on Monday 1 to 53
|
|
F A full textual representation of a month, such as January or March January to December
|
|
m Numeric representation of a month, with leading zeros 01 to 12
|
|
M A short textual representation of a month, three letters Jan to Dec
|
|
n Numeric representation of a month, without leading zeros 1 to 12
|
|
t Number of days in the given month 28 to 31
|
|
L Whether it's a leap year 1 if it is a leap year, 0 otherwise.
|
|
Y A full numeric representation of a year, 4 digits Examples: 1999 or 2003
|
|
y A two digit representation of a year Examples: 99 or 03
|
|
a Lowercase Ante meridiem and Post meridiem am or pm
|
|
A Uppercase Ante meridiem and Post meridiem AM or PM
|
|
g 12-hour format of an hour without leading zeros 1 to 12
|
|
G 24-hour format of an hour without leading zeros 0 to 23
|
|
h 12-hour format of an hour with leading zeros 01 to 12
|
|
H 24-hour format of an hour with leading zeros 00 to 23
|
|
i Minutes, with leading zeros 00 to 59
|
|
s Seconds, with leading zeros 00 to 59
|
|
u Milliseconds, with leading zeros 001 to 999
|
|
O Difference to Greenwich time (GMT) in hours Example: +0200
|
|
T Timezone abbreviation of the machine running the code Examples: EST, MDT ...
|
|
Z Timezone offset in seconds (negative if west of UTC, positive if east) -43200 to 50400
|
|
</pre>
|
|
*
|
|
* Example usage (note that you must escape format specifiers with '\\' to render them as character literals):
|
|
* <pre><code>
|
|
// Sample date:
|
|
// 'Wed Jan 10 2007 15:05:01 GMT-0600 (Central Standard Time)'
|
|
|
|
var dt = new Date('1/10/2007 03:05:01 PM GMT-0600');
|
|
document.write(dt.format('Y-m-d')); //2007-01-10
|
|
document.write(dt.format('F j, Y, g:i a')); //January 10, 2007, 3:05 pm
|
|
document.write(dt.format('l, \\t\\he dS of F Y h:i:s A')); //Wednesday, the 10th of January 2007 03:05:01 PM
|
|
</code></pre>
|
|
*
|
|
* Here are some standard date/time patterns that you might find helpful. They
|
|
* are not part of the source of Date.js, but to use them you can simply copy this
|
|
* block of code into any script that is included after Date.js and they will also become
|
|
* globally available on the Date object. Feel free to add or remove patterns as needed in your code.
|
|
* <pre><code>
|
|
Date.patterns = {
|
|
ISO8601Long:"Y-m-d H:i:s",
|
|
ISO8601Short:"Y-m-d",
|
|
ShortDate: "n/j/Y",
|
|
LongDate: "l, F d, Y",
|
|
FullDateTime: "l, F d, Y g:i:s A",
|
|
MonthDay: "F d",
|
|
ShortTime: "g:i A",
|
|
LongTime: "g:i:s A",
|
|
SortableDateTime: "Y-m-d\\TH:i:s",
|
|
UniversalSortableDateTime: "Y-m-d H:i:sO",
|
|
YearMonth: "F, Y"
|
|
};
|
|
</code></pre>
|
|
*
|
|
* Example usage:
|
|
* <pre><code>
|
|
var dt = new Date();
|
|
document.write(dt.format(Date.patterns.ShortDate));
|
|
</code></pre>
|
|
*/
|
|
|
|
/*
|
|
* Most of the date-formatting functions below are the excellent work of Baron Schwartz.
|
|
* They generate precompiled functions from date formats instead of parsing and
|
|
* processing the pattern every time you format a date. These functions are available
|
|
* on every Date object (any javascript function).
|
|
*
|
|
* The original article and download are here:
|
|
* http://www.xaprb.com/blog/2005/12/12/javascript-closures-for-runtime-efficiency/
|
|
*
|
|
*/
|
|
|
|
// private
|
|
Date.parseFunctions = {count:0};
|
|
// private
|
|
Date.parseRegexes = [];
|
|
// private
|
|
Date.formatFunctions = {count:0};
|
|
|
|
// private
|
|
Date.prototype.dateFormat = function(format) {
|
|
if (Date.formatFunctions[format] == null) {
|
|
Date.createNewFormat(format);
|
|
}
|
|
var func = Date.formatFunctions[format];
|
|
return this[func]();
|
|
};
|
|
|
|
|
|
/**
|
|
* Formats a date given the supplied format string
|
|
* @param {String} format The format string
|
|
* @return {String} The formatted date
|
|
* @method
|
|
*/
|
|
Date.prototype.format = Date.prototype.dateFormat;
|
|
|
|
// private
|
|
Date.createNewFormat = function(format) {
|
|
var funcName = "format" + Date.formatFunctions.count++;
|
|
Date.formatFunctions[format] = funcName;
|
|
var code = "Date.prototype." + funcName + " = function(){return ";
|
|
var special = false;
|
|
var ch = '';
|
|
for (var i = 0; i < format.length; ++i) {
|
|
ch = format.charAt(i);
|
|
if (!special && ch == "\\") {
|
|
special = true;
|
|
}
|
|
else if (special) {
|
|
special = false;
|
|
code += "'" + String.escape(ch) + "' + ";
|
|
}
|
|
else {
|
|
code += Date.getFormatCode(ch);
|
|
}
|
|
}
|
|
eval(code.substring(0, code.length - 3) + ";}");
|
|
};
|
|
|
|
// private
|
|
Date.getFormatCode = function(character) {
|
|
switch (character) {
|
|
case "d":
|
|
return "String.leftPad(this.getDate(), 2, '0') + ";
|
|
case "D":
|
|
return "Date.dayNames[this.getDay()].substring(0, 3) + ";
|
|
case "j":
|
|
return "this.getDate() + ";
|
|
case "l":
|
|
return "Date.dayNames[this.getDay()] + ";
|
|
case "S":
|
|
return "this.getSuffix() + ";
|
|
case "w":
|
|
return "this.getDay() + ";
|
|
case "z":
|
|
return "this.getDayOfYear() + ";
|
|
case "W":
|
|
return "this.getWeekOfYear() + ";
|
|
case "F":
|
|
return "Date.monthNames[this.getMonth()] + ";
|
|
case "m":
|
|
return "String.leftPad(this.getMonth() + 1, 2, '0') + ";
|
|
case "M":
|
|
return "Date.monthNames[this.getMonth()].substring(0, 3) + ";
|
|
case "n":
|
|
return "(this.getMonth() + 1) + ";
|
|
case "t":
|
|
return "this.getDaysInMonth() + ";
|
|
case "L":
|
|
return "(this.isLeapYear() ? 1 : 0) + ";
|
|
case "Y":
|
|
return "this.getFullYear() + ";
|
|
case "y":
|
|
return "('' + this.getFullYear()).substring(2, 4) + ";
|
|
case "a":
|
|
return "(this.getHours() < 12 ? 'am' : 'pm') + ";
|
|
case "A":
|
|
return "(this.getHours() < 12 ? 'AM' : 'PM') + ";
|
|
case "g":
|
|
return "((this.getHours() % 12) ? this.getHours() % 12 : 12) + ";
|
|
case "G":
|
|
return "this.getHours() + ";
|
|
case "h":
|
|
return "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0') + ";
|
|
case "H":
|
|
return "String.leftPad(this.getHours(), 2, '0') + ";
|
|
case "i":
|
|
return "String.leftPad(this.getMinutes(), 2, '0') + ";
|
|
case "s":
|
|
return "String.leftPad(this.getSeconds(), 2, '0') + ";
|
|
case "u":
|
|
return "String.leftPad(this.getMilliseconds(), 3, '0') + ";
|
|
case "O":
|
|
return "this.getGMTOffset() + ";
|
|
case "T":
|
|
return "this.getTimezone() + ";
|
|
case "Z":
|
|
return "(this.getTimezoneOffset() * -60) + ";
|
|
default:
|
|
return "'" + String.escape(character) + "' + ";
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Parses the passed string using the specified format. Note that this function expects dates in normal calendar
|
|
* format, meaning that months are 1-based (1 = January) and not zero-based like in JavaScript dates. Any part of
|
|
* the date format that is not specified will default to the current date value for that part. Time parts can also
|
|
* be specified, but default to 0. Keep in mind that the input date string must precisely match the specified format
|
|
* string or the parse operation will fail.
|
|
* Example Usage:
|
|
<pre><code>
|
|
//dt = Fri May 25 2007 (current date)
|
|
var dt = new Date();
|
|
|
|
//dt = Thu May 25 2006 (today's month/day in 2006)
|
|
dt = Date.parseDate("2006", "Y");
|
|
|
|
//dt = Sun Jan 15 2006 (all date parts specified)
|
|
dt = Date.parseDate("2006-01-15", "Y-m-d");
|
|
|
|
//dt = Sun Jan 15 2006 15:20:01 GMT-0600 (CST)
|
|
dt = Date.parseDate("2006-01-15 3:20:01 PM", "Y-m-d h:i:s A" );
|
|
</code></pre>
|
|
* @param {String} input The unparsed date as a string
|
|
* @param {String} format The format the date is in
|
|
* @return {Date} The parsed date
|
|
* @static
|
|
*/
|
|
Date.parseDate = function(input, format) {
|
|
if (Date.parseFunctions[format] == null) {
|
|
Date.createParser(format);
|
|
}
|
|
var func = Date.parseFunctions[format];
|
|
return Date[func](input);
|
|
};
|
|
|
|
// private
|
|
Date.createParser = function(format) {
|
|
var funcName = "parse" + Date.parseFunctions.count++;
|
|
var regexNum = Date.parseRegexes.length;
|
|
var currentGroup = 1;
|
|
Date.parseFunctions[format] = funcName;
|
|
|
|
var code = "Date." + funcName + " = function(input){\n"
|
|
+ "var y = -1, m = -1, d = -1, h = -1, i = -1, s = -1, ms = -1, o, z, v;\n"
|
|
+ "var d = new Date();\n"
|
|
+ "y = d.getFullYear();\n"
|
|
+ "m = d.getMonth();\n"
|
|
+ "d = d.getDate();\n"
|
|
+ "var results = input.match(Date.parseRegexes[" + regexNum + "]);\n"
|
|
+ "if (results && results.length > 0) {";
|
|
var regex = "";
|
|
|
|
var special = false;
|
|
var ch = '';
|
|
for (var i = 0; i < format.length; ++i) {
|
|
ch = format.charAt(i);
|
|
if (!special && ch == "\\") {
|
|
special = true;
|
|
}
|
|
else if (special) {
|
|
special = false;
|
|
regex += String.escape(ch);
|
|
}
|
|
else {
|
|
var obj = Date.formatCodeToRegex(ch, currentGroup);
|
|
currentGroup += obj.g;
|
|
regex += obj.s;
|
|
if (obj.g && obj.c) {
|
|
code += obj.c;
|
|
}
|
|
}
|
|
}
|
|
|
|
code += "if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0 && ms >= 0)\n"
|
|
+ "{v = new Date(y, m, d, h, i, s, ms);}\n"
|
|
+ "else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0 && s >= 0)\n"
|
|
+ "{v = new Date(y, m, d, h, i, s);}\n"
|
|
+ "else if (y >= 0 && m >= 0 && d > 0 && h >= 0 && i >= 0)\n"
|
|
+ "{v = new Date(y, m, d, h, i);}\n"
|
|
+ "else if (y >= 0 && m >= 0 && d > 0 && h >= 0)\n"
|
|
+ "{v = new Date(y, m, d, h);}\n"
|
|
+ "else if (y >= 0 && m >= 0 && d > 0)\n"
|
|
+ "{v = new Date(y, m, d);}\n"
|
|
+ "else if (y >= 0 && m >= 0)\n"
|
|
+ "{v = new Date(y, m);}\n"
|
|
+ "else if (y >= 0)\n"
|
|
+ "{v = new Date(y);}\n"
|
|
+ "}return (v && (z || o))?\n" // favour UTC offset over GMT offset
|
|
+ " ((z)? v.add(Date.SECOND, (v.getTimezoneOffset() * 60) + (z*1)) :\n" // reset to UTC, then add offset
|
|
+ " v.add(Date.HOUR, (v.getGMTOffset() / 100) + (o / -100))) : v\n" // reset to GMT, then add offset
|
|
+ ";}";
|
|
|
|
Date.parseRegexes[regexNum] = new RegExp("^" + regex + "$", "i");
|
|
eval(code);
|
|
};
|
|
|
|
// private
|
|
Date.formatCodeToRegex = function(character, currentGroup) {
|
|
/*
|
|
* currentGroup = position in regex result array
|
|
* g = calculation group (0 or 1. only group 1 contributes to date calculations.)
|
|
* c = calculation method (required for group 1. null for group 0.)
|
|
* s = regex string
|
|
*/
|
|
switch (character) {
|
|
case "D":
|
|
return {g:0,
|
|
c:null,
|
|
s:"(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat)"};
|
|
case "j":
|
|
return {g:1,
|
|
c:"d = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{1,2})"}; // day of month without leading zeroes
|
|
case "d":
|
|
return {g:1,
|
|
c:"d = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{2})"}; // day of month with leading zeroes
|
|
case "l":
|
|
return {g:0,
|
|
c:null,
|
|
s:"(?:" + Date.dayNames.join("|") + ")"};
|
|
case "S":
|
|
return {g:0,
|
|
c:null,
|
|
s:"(?:st|nd|rd|th)"};
|
|
case "w":
|
|
return {g:0,
|
|
c:null,
|
|
s:"\\d"};
|
|
case "z":
|
|
return {g:0,
|
|
c:null,
|
|
s:"(?:\\d{1,3})"};
|
|
case "W":
|
|
return {g:0,
|
|
c:null,
|
|
s:"(?:\\d{1,2})"};
|
|
case "F":
|
|
return {g:1,
|
|
c:"m = parseInt(Date.monthNumbers[results[" + currentGroup + "].substring(0, 1).toUpperCase() + results[" + currentGroup + "].substring(1, 3).toLowerCase()], 10);\n",
|
|
s:"(" + Date.monthNames.join("|") + ")"};
|
|
case "M":
|
|
return {g:1,
|
|
c:"m = parseInt(Date.monthNumbers[results[" + currentGroup + "].substring(0, 1).toUpperCase() + results[" + currentGroup + "].substring(1, 3).toLowerCase()], 10);\n",
|
|
s:"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)"};
|
|
case "n":
|
|
return {g:1,
|
|
c:"m = parseInt(results[" + currentGroup + "], 10) - 1;\n",
|
|
s:"(\\d{1,2})"}; // Numeric representation of a month, without leading zeros
|
|
case "m":
|
|
return {g:1,
|
|
c:"m = parseInt(results[" + currentGroup + "], 10) - 1;\n",
|
|
s:"(\\d{2})"}; // Numeric representation of a month, with leading zeros
|
|
case "t":
|
|
return {g:0,
|
|
c:null,
|
|
s:"\\d{1,2}"};
|
|
case "L":
|
|
return {g:0,
|
|
c:null,
|
|
s:"(?:1|0)"};
|
|
case "Y":
|
|
return {g:1,
|
|
c:"y = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{4})"};
|
|
case "y":
|
|
return {g:1,
|
|
c:"var ty = parseInt(results[" + currentGroup + "], 10);\n"
|
|
+ "y = ty > Date.y2kYear ? 1900 + ty : 2000 + ty;\n",
|
|
s:"(\\d{1,2})"};
|
|
case "a":
|
|
return {g:1,
|
|
c:"if (results[" + currentGroup + "] == 'am') {\n"
|
|
+ "if (h == 12) { h = 0; }\n"
|
|
+ "} else { if (h < 12) { h += 12; }}",
|
|
s:"(am|pm)"};
|
|
case "A":
|
|
return {g:1,
|
|
c:"if (results[" + currentGroup + "] == 'AM') {\n"
|
|
+ "if (h == 12) { h = 0; }\n"
|
|
+ "} else { if (h < 12) { h += 12; }}",
|
|
s:"(AM|PM)"};
|
|
case "g":
|
|
case "G":
|
|
return {g:1,
|
|
c:"h = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{1,2})"}; // 12/24-hr format format of an hour without leading zeroes
|
|
case "h":
|
|
case "H":
|
|
return {g:1,
|
|
c:"h = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{2})"}; // 12/24-hr format format of an hour with leading zeroes
|
|
case "i":
|
|
return {g:1,
|
|
c:"i = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{2})"};
|
|
case "s":
|
|
return {g:1,
|
|
c:"s = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{2})"};
|
|
case "u":
|
|
return {g:1,
|
|
c:"ms = parseInt(results[" + currentGroup + "], 10);\n",
|
|
s:"(\\d{3})"};
|
|
case "O":
|
|
return {g:1,
|
|
c:[
|
|
"o = results[", currentGroup, "];\n",
|
|
"var sn = o.substring(0,1);\n", // get + / - sign
|
|
"var hr = o.substring(1,3)*1 + Math.floor(o.substring(3,5) / 60);\n", // get hours (performs minutes-to-hour conversion also)
|
|
"var mn = o.substring(3,5) % 60;\n", // get minutes
|
|
"o = ((-12 <= (hr*60 + mn)/60) && ((hr*60 + mn)/60 <= 14))?\n", // -12hrs <= GMT offset <= 14hrs
|
|
" (sn + String.leftPad(hr, 2, 0) + String.leftPad(mn, 2, 0)) : null;\n"
|
|
].join(""),
|
|
s:"([+\-]\\d{4})"};
|
|
case "T":
|
|
return {g:0,
|
|
c:null,
|
|
s:"[A-Z]{1,4}"}; // timezone abbrev. may be between 1 - 4 chars
|
|
case "Z":
|
|
return {g:1,
|
|
c:"z = results[" + currentGroup + "] * 1;\n" // -43200 <= UTC offset <= 50400
|
|
+ "z = (-43200 <= z && z <= 50400)? z : null;\n",
|
|
s:"([+\-]?\\d{1,5})"}; // leading '+' sign is optional for UTC offset
|
|
default:
|
|
return {g:0,
|
|
c:null,
|
|
s:String.escape(character)};
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Get the timezone abbreviation of the current date (equivalent to the format specifier 'T').
|
|
* @return {String} The abbreviated timezone name (e.g. 'CST')
|
|
*/
|
|
Date.prototype.getTimezone = function() {
|
|
return this.toString().replace(/^.*? ([A-Z]{1,4})[\-+][0-9]{4} .*$/, "$1");
|
|
};
|
|
|
|
/**
|
|
* Get the offset from GMT of the current date (equivalent to the format specifier 'O').
|
|
* @return {String} The 4-character offset string prefixed with + or - (e.g. '-0600')
|
|
*/
|
|
Date.prototype.getGMTOffset = function() {
|
|
return (this.getTimezoneOffset() > 0 ? "-" : "+")
|
|
+ String.leftPad(Math.abs(Math.floor(this.getTimezoneOffset() / 60)), 2, "0")
|
|
+ String.leftPad(this.getTimezoneOffset() % 60, 2, "0");
|
|
};
|
|
|
|
/**
|
|
* Get the numeric day number of the year, adjusted for leap year.
|
|
* @return {Number} 0 to 364 (365 in leap years)
|
|
*/
|
|
Date.prototype.getDayOfYear = function() {
|
|
var num = 0;
|
|
Date.daysInMonth[1] = this.isLeapYear() ? 29 : 28;
|
|
for (var i = 0; i < this.getMonth(); ++i) {
|
|
num += Date.daysInMonth[i];
|
|
}
|
|
return num + this.getDate() - 1;
|
|
};
|
|
|
|
/**
|
|
* Get the numeric ISO-8601 week number of the year
|
|
* (equivalent to the format specifier 'W').
|
|
* @return {Number} 1 to 53
|
|
*/
|
|
Date.prototype.getWeekOfYear = function() {
|
|
/*
|
|
original getWeek() function developed by Nick Baicoianu
|
|
at MeanFreePath: http://www.meanfreepath.com
|
|
*/
|
|
var jan1 = new Date(this.getFullYear(), 0, 1);
|
|
var day = jan1.getDay() - 1; // the day of week the year begins on
|
|
day = (day >= 0 ? day : day + 7);
|
|
var daynum = Math.floor((this.getTime() - jan1.getTime() - (this.getTimezoneOffset()-jan1.getTimezoneOffset())*60000)/86400000) + 1;
|
|
var weeknum;
|
|
// if the year starts before the middle of a week
|
|
if (day < 4) {
|
|
weeknum = Math.floor((daynum + day - 1) / 7) + 1;
|
|
if (weeknum > 52) {
|
|
jan1 = new Date(this.getFullYear() + 1, 0, 1);
|
|
day = jan1.getDay() - 1;
|
|
day = (day >= 0 ? day : day + 7);
|
|
// if the next year starts before the middle of the week, it is week #1 of that year
|
|
weeknum = day < 4 ? 1 : 53;
|
|
}
|
|
} else {
|
|
weeknum = Math.floor((daynum + day - 1) / 7) || 52;
|
|
}
|
|
return weeknum;
|
|
};
|
|
|
|
/**
|
|
* Whether or not the current date is in a leap year.
|
|
* @return {Boolean} True if the current date is in a leap year, else false
|
|
*/
|
|
Date.prototype.isLeapYear = function() {
|
|
var year = this.getFullYear();
|
|
return ((year & 3) == 0 && (year % 100 || (year % 400 == 0 && year)));
|
|
};
|
|
|
|
/**
|
|
* Get the first day of the current month, adjusted for leap year. The returned value
|
|
* is the numeric day index within the week (0-6) which can be used in conjunction with
|
|
* the {@link #monthNames} array to retrieve the textual day name.
|
|
* Example:
|
|
*<pre><code>
|
|
var dt = new Date('1/10/2007');
|
|
document.write(Date.dayNames[dt.getFirstDayOfMonth()]); //output: 'Monday'
|
|
</code></pre>
|
|
* @return {Number} The day number (0-6)
|
|
*/
|
|
Date.prototype.getFirstDayOfMonth = function() {
|
|
var day = (this.getDay() - (this.getDate() - 1)) % 7;
|
|
return (day < 0) ? (day + 7) : day;
|
|
};
|
|
|
|
/**
|
|
* Get the last day of the current month, adjusted for leap year. The returned value
|
|
* is the numeric day index within the week (0-6) which can be used in conjunction with
|
|
* the {@link #monthNames} array to retrieve the textual day name.
|
|
* Example:
|
|
*<pre><code>
|
|
var dt = new Date('1/10/2007');
|
|
document.write(Date.dayNames[dt.getLastDayOfMonth()]); //output: 'Wednesday'
|
|
</code></pre>
|
|
* @return {Number} The day number (0-6)
|
|
*/
|
|
Date.prototype.getLastDayOfMonth = function() {
|
|
var day = (this.getDay() + (Date.daysInMonth[this.getMonth()] - this.getDate())) % 7;
|
|
return (day < 0) ? (day + 7) : day;
|
|
};
|
|
|
|
|
|
/**
|
|
* Get the date of the first day of the month in which this date resides
|
|
* @return {Date}
|
|
*/
|
|
Date.prototype.getFirstDateOfMonth = function() {
|
|
return new Date(this.getFullYear(), this.getMonth(), 1);
|
|
};
|
|
|
|
/**
|
|
* Get the date of the last day of the month in which this date resides
|
|
* @return {Date}
|
|
*/
|
|
Date.prototype.getLastDateOfMonth = function() {
|
|
return new Date(this.getFullYear(), this.getMonth(), this.getDaysInMonth());
|
|
};
|
|
/**
|
|
* Get the number of days in the current month, adjusted for leap year.
|
|
* @return {Number} The number of days in the month
|
|
*/
|
|
Date.prototype.getDaysInMonth = function() {
|
|
Date.daysInMonth[1] = this.isLeapYear() ? 29 : 28;
|
|
return Date.daysInMonth[this.getMonth()];
|
|
};
|
|
|
|
/**
|
|
* Get the English ordinal suffix of the current day (equivalent to the format specifier 'S').
|
|
* @return {String} 'st, 'nd', 'rd' or 'th'
|
|
*/
|
|
Date.prototype.getSuffix = function() {
|
|
switch (this.getDate()) {
|
|
case 1:
|
|
case 21:
|
|
case 31:
|
|
return "st";
|
|
case 2:
|
|
case 22:
|
|
return "nd";
|
|
case 3:
|
|
case 23:
|
|
return "rd";
|
|
default:
|
|
return "th";
|
|
}
|
|
};
|
|
|
|
// private
|
|
Date.daysInMonth = [31,28,31,30,31,30,31,31,30,31,30,31];
|
|
|
|
/**
|
|
* An array of textual month names.
|
|
* Override these values for international dates, for example...
|
|
* Date.monthNames = ['JanInYourLang', 'FebInYourLang', ...];
|
|
* @type Array
|
|
* @static
|
|
*/
|
|
Date.monthNames =
|
|
["January",
|
|
"February",
|
|
"March",
|
|
"April",
|
|
"May",
|
|
"June",
|
|
"July",
|
|
"August",
|
|
"September",
|
|
"October",
|
|
"November",
|
|
"December"];
|
|
|
|
/**
|
|
* An array of textual day names.
|
|
* Override these values for international dates, for example...
|
|
* Date.dayNames = ['SundayInYourLang', 'MondayInYourLang', ...];
|
|
* @type Array
|
|
* @static
|
|
*/
|
|
Date.dayNames =
|
|
["Sunday",
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday"];
|
|
|
|
// private
|
|
Date.y2kYear = 50;
|
|
// private
|
|
Date.monthNumbers = {
|
|
Jan:0,
|
|
Feb:1,
|
|
Mar:2,
|
|
Apr:3,
|
|
May:4,
|
|
Jun:5,
|
|
Jul:6,
|
|
Aug:7,
|
|
Sep:8,
|
|
Oct:9,
|
|
Nov:10,
|
|
Dec:11};
|
|
|
|
/**
|
|
* Creates and returns a new Date instance with the exact same date value as the called instance.
|
|
* Dates are copied and passed by reference, so if a copied date variable is modified later, the original
|
|
* variable will also be changed. When the intention is to create a new variable that will not
|
|
* modify the original instance, you should create a clone.
|
|
*
|
|
* Example of correctly cloning a date:
|
|
* <pre><code>
|
|
//wrong way:
|
|
var orig = new Date('10/1/2006');
|
|
var copy = orig;
|
|
copy.setDate(5);
|
|
document.write(orig); //returns 'Thu Oct 05 2006'!
|
|
|
|
//correct way:
|
|
var orig = new Date('10/1/2006');
|
|
var copy = orig.clone();
|
|
copy.setDate(5);
|
|
document.write(orig); //returns 'Thu Oct 01 2006'
|
|
</code></pre>
|
|
* @return {Date} The new Date instance
|
|
*/
|
|
Date.prototype.clone = function() {
|
|
return new Date(this.getTime());
|
|
};
|
|
|
|
/**
|
|
* Clears any time information from this date
|
|
@param {Boolean} clone true to create a clone of this date, clear the time and return it
|
|
@return {Date} this or the clone
|
|
*/
|
|
Date.prototype.clearTime = function(clone){
|
|
if(clone){
|
|
return this.clone().clearTime();
|
|
}
|
|
this.setHours(0);
|
|
this.setMinutes(0);
|
|
this.setSeconds(0);
|
|
this.setMilliseconds(0);
|
|
return this;
|
|
};
|
|
|
|
// private
|
|
// safari setMonth is broken
|
|
//if(Ext.isSafari){
|
|
// Date.brokenSetMonth = Date.prototype.setMonth;
|
|
// Date.prototype.setMonth = function(num){
|
|
// if(num <= -1){
|
|
// var n = Math.ceil(-num);
|
|
// var back_year = Math.ceil(n/12);
|
|
// var month = (n % 12) ? 12 - n % 12 : 0 ;
|
|
// this.setFullYear(this.getFullYear() - back_year);
|
|
// return Date.brokenSetMonth.call(this, month);
|
|
// } else {
|
|
// return Date.brokenSetMonth.apply(this, arguments);
|
|
// }
|
|
// };
|
|
//}
|
|
|
|
/** Date interval constant @static @type String */
|
|
Date.MILLI = "ms";
|
|
/** Date interval constant @static @type String */
|
|
Date.SECOND = "s";
|
|
/** Date interval constant @static @type String */
|
|
Date.MINUTE = "mi";
|
|
/** Date interval constant @static @type String */
|
|
Date.HOUR = "h";
|
|
/** Date interval constant @static @type String */
|
|
Date.DAY = "d";
|
|
/** Date interval constant @static @type String */
|
|
Date.MONTH = "mo";
|
|
/** Date interval constant @static @type String */
|
|
Date.YEAR = "y";
|
|
|
|
/**
|
|
* Provides a convenient method of performing basic date arithmetic. This method
|
|
* does not modify the Date instance being called - it creates and returns
|
|
* a new Date instance containing the resulting date value.
|
|
*
|
|
* Examples:
|
|
* <pre><code>
|
|
//Basic usage:
|
|
var dt = new Date('10/29/2006').add(Date.DAY, 5);
|
|
document.write(dt); //returns 'Fri Oct 06 2006 00:00:00'
|
|
|
|
//Negative values will subtract correctly:
|
|
var dt2 = new Date('10/1/2006').add(Date.DAY, -5);
|
|
document.write(dt2); //returns 'Tue Sep 26 2006 00:00:00'
|
|
|
|
//You can even chain several calls together in one line!
|
|
var dt3 = new Date('10/1/2006').add(Date.DAY, 5).add(Date.HOUR, 8).add(Date.MINUTE, -30);
|
|
document.write(dt3); //returns 'Fri Oct 06 2006 07:30:00'
|
|
</code></pre>
|
|
*
|
|
* @param {String} interval A valid date interval enum value
|
|
* @param {Number} value The amount to add to the current date
|
|
* @return {Date} The new Date instance
|
|
*/
|
|
Date.prototype.add = function(interval, value){
|
|
var d = this.clone();
|
|
if (!interval || value === 0) return d;
|
|
switch(interval.toLowerCase()){
|
|
case Date.MILLI:
|
|
d.setMilliseconds(this.getMilliseconds() + value);
|
|
break;
|
|
case Date.SECOND:
|
|
d.setSeconds(this.getSeconds() + value);
|
|
break;
|
|
case Date.MINUTE:
|
|
d.setMinutes(this.getMinutes() + value);
|
|
break;
|
|
case Date.HOUR:
|
|
d.setHours(this.getHours() + value);
|
|
break;
|
|
case Date.DAY:
|
|
d.setDate(this.getDate() + value);
|
|
break;
|
|
case Date.MONTH:
|
|
var day = this.getDate();
|
|
if(day > 28){
|
|
day = Math.min(day, this.getFirstDateOfMonth().add('mo', value).getLastDateOfMonth().getDate());
|
|
}
|
|
d.setDate(day);
|
|
d.setMonth(this.getMonth() + value);
|
|
break;
|
|
case Date.YEAR:
|
|
d.setFullYear(this.getFullYear() + value);
|
|
break;
|
|
}
|
|
return d;
|
|
};
|
|
|
|
/**
|
|
* Checks if this date falls on or between the given start and end dates
|
|
* @param {Date} start Start date
|
|
* @param {Date} end End date
|
|
* @return {Boolean} true if this date falls on or between the given start and end dates
|
|
*/
|
|
Date.prototype.between = function(start, end){
|
|
var t = this.getTime();
|
|
return start.getTime() <= t && t <= end.getTime();
|
|
}
|