date.js

java + Ext 实现文件上传功能

/*
 * Ext JS Library 2.1
 * Copyright(c) 2006-2008, Ext JS, LLC.
 * [e-mail]
 * 
 * http://extjs.com/license
 */

/**
 * @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.
 *
 * The following is a 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 short textual representation of the day of the week                     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
  N     ISO-8601 numeric representation of the day of the week                    1 (for Monday) through 7 (for Sunday)
  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                    01 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                                 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.
  o     ISO-8601 year number (identical to (Y), but if the ISO week number (W)    Examples: 1998 or 2004
        belongs to the previous or next year, that year is used instead)
  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 and minutes                   Example: +1030
  P     Difference to Greenwich time (GMT) with colon between hours and minutes   Example: -08:00
  T     Timezone abbreviation of the machine running the code                     Examples: EST, MDT, PDT ...
  Z     Timezone offset in seconds (negative if west of UTC, positive if east)    -43200 to 50400
  c     ISO 8601 date                                                             2007-04-17T15:19:21+08:00 or
                                                                                  2007-04-17T15:19:21Z
  U     Seconds since the Unix Epoch (January 1 1970 00:00:00 GMT)                1193432466 or -2138434463
</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 jS 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) + ";}");
};

/**
 * The base format-code to formatting-function hashmap used by the {@link #format} method.
 * Formatting functions are strings (or functions which return strings) which
 * will return the appropriate value when evaluated in the context of the Date object
 * from which the {@link #format} method is called.
 * Add to / override these mappings for custom date formatting.
 * Note: Date.format() treats characters as literals if an appropriate mapping cannot be found.
 * Example:
<pre><code>
Date.formatCodes.x = "String.leftPad(this.getDate(), 2, '0')";
(new Date()).format("X"); // returns the current day of the month
</code></pre>
 * @type Object
 * @static
 */
Date.formatCodes = {
    d: "String.leftPad(this.getDate(), 2, '0')",
    D: "Date.getShortDayName(this.getDay())", // get localised short day name
    j: "this.getDate()",
    l: "Date.dayNames[this.getDay()]",
    N: "(this.getDay() ? this.getDay() : 7)",
    S: "this.getSuffix()",
    w: "this.getDay()",
    z: "this.getDayOfYear()",
    W: "String.leftPad(this.getWeekOfYear(), 2, '0')",
    F: "Date.monthNames[this.getMonth()]",
    m: "String.leftPad(this.getMonth() + 1, 2, '0')",
    M: "Date.getShortMonthName(this.getMonth())", // get localised short month name
    n: "(this.getMonth() + 1)",
    t: "this.getDaysInMonth()",
    L: "(this.isLeapYear() ? 1 : 0)",
    o: "(this.getFullYear() + (this.getWeekOfYear() == 1 && this.getMonth() > 0 ? +1 : (this.getWeekOfYear() >= 52 && this.getMonth() < 11 ? -1 : 0)))",
    Y: "this.getFullYear()",
    y: "('' + this.getFullYear()).substring(2, 4)",
    a: "(this.getHours() < 12 ? 'am' : 'pm')",
    A: "(this.getHours() < 12 ? 'AM' : 'PM')",
    g: "((this.getHours() % 12) ? this.getHours() % 12 : 12)",
    G: "this.getHours()",
    h: "String.leftPad((this.getHours() % 12) ? this.getHours() % 12 : 12, 2, '0')",
    H: "String.leftPad(this.getHours(), 2, '0')",
    i: "String.leftPad(this.getMinutes(), 2, '0')",
    s: "String.leftPad(this.getSeconds(), 2, '0')",
    u: "String.leftPad(this.getMilliseconds(), 3, '0')",
    O: "this.getGMTOffset()",
    P: "this.getGMTOffset(true)",
    T: "this.getTimezone()",
    Z: "(this.getTimezoneOffset() * -60)",
    c: function() { // ISO-8601 -- GMT format
        for (var c = "Y-m-dTH:i:sP", code = [], i = 0, l = c.length; i < l; ++i) {
            var e = c.charAt(i);
            code.push(e == "T" ? "'T'" : Date.getFormatCode(e)); // treat T as a character literal
        }
        return code.join(" + ");
    },
    /*
    c: function() { // ISO-8601 -- UTC format
        return [
          "this.getUTCFullYear()", "'-'",
          "String.leftPad(this.getUTCMonth() + 1, 2, '0')", "'-'", 
          "String.leftPad(this.getUTCDate(), 2, '0')",
          "'T'",
          "String.leftPad(this.getUTCHours(), 2, '0')", "':'",
          "String.leftPad(this.getUTCMinutes(), 2, '0')", "':'",
          "String.leftPad(this.getUTCSeconds(), 2, '0')",
          "'Z'"
        ].join(" + ");
    },
    */
    U: "Math.round(this.getTime() / 1000)"
}

// private
Date.getFormatCode = function(character) {
    var f = Date.formatCodes[character];
    
    if (f) {
      f = Ext.type(f) == 'function'? f() : f;
      Date.formatCodes[character] = f; // reassign function result to prevent repeated execution
    }

    // note: unknown characters are treated as literals
    return f || ("'" + 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, u, v;\n"
        + "input = String(input);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 (u){\n"
        + "v = new Date(u * 1000);\n" // give top priority to UNIX time
        + "}else 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"
        + "}\n}\nreturn (v && Ext.type(z || o) == 'number')?" // favour UTC offset over GMT offset
        +     " (Ext.type(z) == 'number' ? v.add(Date.SECOND, (v.getTimezoneOffset() * 60) + z) :" // reset to UTC, then add offset