sugar-js-vs-moment-vs-raw (v2)

Revision 2 of this benchmark created on

Preparation HTML

<script src="http://sugarjs.com/release/current/sugar.min.js"></script>
<script src="http://momentjs.com/downloads/moment.min.js"></script>


<script>
/**
 * @preserve XDate v@VERSION
 * Docs & Licensing: http://arshaw.com/xdate/
 */

/*
 * Internal Architecture
 * ---------------------
 * An XDate wraps a native Date. The native Date is stored in the '0' property of the object.
 * UTC-mode is determined by whether the internal native Date's toString method is set to
 * Date.prototype.toUTCString (see getUTCMode).
 *
 */

var XDate = (function(Date, Math, Array, undefined) {


/** @const */ var FULLYEAR     = 0;
/** @const */ var MONTH        = 1;
/** @const */ var DATE         = 2;
/** @const */ var HOURS        = 3;
/** @const */ var MINUTES      = 4;
/** @const */ var SECONDS      = 5;
/** @const */ var MILLISECONDS = 6;
/** @const */ var DAY          = 7;
/** @const */ var YEAR         = 8;
/** @const */ var WEEK         = 9;
/** @const */ var DAY_MS = 86400000;
var ISO_FORMAT_STRING = "yyyy-MM-dd'T'HH:mm:ss(.fff)";
var ISO_FORMAT_STRING_TZ = ISO_FORMAT_STRING + "zzz";


var methodSubjects = [
        'FullYear',     // 0
        'Month',        // 1
        'Date',         // 2
        'Hours',        // 3
        'Minutes',      // 4
        'Seconds',      // 5
        'Milliseconds', // 6
        'Day',          // 7
        'Year'          // 8
];
var subjectPlurals = [
        'Years',        // 0
        'Months',       // 1
        'Days'          // 2
];
var unitsWithin = [
        12,   // months in year
        31,   // days in month (sort of)
        24,   // hours in day
        60,   // minutes in hour
        60,   // seconds in minute
        1000, // milliseconds in second
        1     //
];
var formatStringRE = new RegExp(
        "(([a-zA-Z])\\2*)|" + // 1, 2
        "(\\(" + "(('.*?'|\\(.*?\\)|.)*?)" + "\\))|" + // 3, 4, 5 (allows for 1 level of inner quotes or parens)
        "('(.*?)')" // 6, 7
);
var UTC = Date.UTC;
var toUTCString = Date.prototype.toUTCString;
var proto = XDate.prototype;



// This makes an XDate look pretty in Firebug and Web Inspector.
// It makes an XDate seem array-like, and displays [ <internal-date>.toString() ]
proto.length = 1;
proto.splice = Array.prototype.splice;




/* Constructor
---------------------------------------------------------------------------------*/

// TODO: in future, I'd change signature for the constructor regarding the `true` utc-mode param. ~ashaw
//   I'd move the boolean to be the *first* argument. Still optional. Seems cleaner.
//   I'd remove it from the `xdate`, `nativeDate`, and `milliseconds` constructors.
//      (because you can simply call .setUTCMode(true) after)
//   And I'd only leave it for the y/m/d/h/m/s/m and `dateString` constructors
//      (because those are the only constructors that need it for DST-gap data-loss reasons)
//   Should do this for 1.0

function XDate() {
        return init(
                (this instanceof XDate) ? this : new XDate(),
                arguments
        );
}


function init(xdate, args) {
        var len = args.length;
        var utcMode;
        if (isBoolean(args[len-1])) {
                utcMode = args[--len];
                args = slice(args, 0, len);
        }
        if (!len) {
                xdate[0] = new Date();
        }
        else if (len == 1) {
                var arg = args[0];
                if (arg instanceof Date || isNumber(arg)) {
                        xdate[0] = new Date(+arg);
                }
                else if (arg instanceof XDate) {
                        xdate[0] = _clone(arg);
                }
                else if (isString(arg)) {
                        xdate[0] = new Date(0);
                        xdate = parse(arg, utcMode || false, xdate);
                }
        }
        else {
                xdate[0] = new Date(UTC.apply(Date, args));
                if (!utcMode) {
                        xdate[0] = coerceToLocal(xdate[0]);
                }
        }
        if (isBoolean(utcMode)) {
                setUTCMode(xdate, utcMode);
        }
        return xdate;
}



/* UTC Mode Methods
---------------------------------------------------------------------------------*/


proto.getUTCMode = methodize(getUTCMode);
function getUTCMode(xdate) {
        return xdate[0].toString === toUTCString;
};


proto.setUTCMode = methodize(setUTCMode);
function setUTCMode(xdate, utcMode, doCoercion) {
        if (utcMode) {
                if (!getUTCMode(xdate)) {
                        if (doCoercion) {
                                xdate[0] = coerceToUTC(xdate[0]);
                        }
                        xdate[0].toString = toUTCString;
                }
        }else{
                if (getUTCMode(xdate)) {
                        if (doCoercion) {
                                xdate[0] = coerceToLocal(xdate[0]);
                        }else{
                                xdate[0] = new Date(+xdate[0]);
                        }
                        // toString will have been cleared
                }
        }
        return xdate; // for chaining
}


proto.getTimezoneOffset = function() {
        if (getUTCMode(this)) {
                return 0;
        }else{
                return this[0].getTimezoneOffset();
        }
};



/* get / set / add / diff Methods (except for week-related)
---------------------------------------------------------------------------------*/


each(methodSubjects, function(subject, fieldIndex) {

        proto['get' + subject] = function() {
                return _getField(this[0], getUTCMode(this), fieldIndex);
        };
        
        if (fieldIndex != YEAR) { // because there is no getUTCYear
        
                proto['getUTC' + subject] = function() {
                        return _getField(this[0], true, fieldIndex);
                };
                
        }

        if (fieldIndex != DAY) { // because there is no setDay or setUTCDay
                                 // and the add* and diff* methods use DATE instead
                
                proto['set' + subject] = function(value) {
                        _set(this, fieldIndex, value, arguments, getUTCMode(this));
                        return this; // for chaining
                };
                
                if (fieldIndex != YEAR) { // because there is no setUTCYear
                                          // and the add* and diff* methods use FULLYEAR instead
                        
                        proto['setUTC' + subject] = function(value) {
                                _set(this, fieldIndex, value, arguments, true);
                                return this; // for chaining
                        };
                        
                        proto['add' + (subjectPlurals[fieldIndex] || subject)] = function(delta, preventOverflow) {
                                _add(this, fieldIndex, delta, preventOverflow);
                                return this; // for chaining
                        };
                        
                        proto['diff' + (subjectPlurals[fieldIndex] || subject)] = function(otherDate) {
                                return _diff(this, otherDate, fieldIndex);
                        };
                        
                }
                
        }

});


function _set(xdate, fieldIndex, value, args, useUTC) {
        var getField = curry(_getField, xdate[0], useUTC);
        var setField = curry(_setField, xdate[0], useUTC);
        var expectedMonth;
        var preventOverflow = false;
        if (args.length == 2 && isBoolean(args[1])) {
                preventOverflow = args[1];
                args = [ value ];
        }
        if (fieldIndex == MONTH) {
                expectedMonth = (value % 12 + 12) % 12;
        }else{
                expectedMonth = getField(MONTH);
        }
        setField(fieldIndex, args);
        if (preventOverflow && getField(MONTH) != expectedMonth) {
                setField(MONTH, [ getField(MONTH) - 1 ]);
                setField(DATE, [ getDaysInMonth(getField(FULLYEAR), getField(MONTH)) ]);
        }
}


function _add(xdate, fieldIndex, delta, preventOverflow) {
        delta = Number(delta);
        var intDelta = Math.floor(delta);
        xdate['set' + methodSubjects[fieldIndex]](
                xdate['get' + methodSubjects[fieldIndex]]() + intDelta,
                preventOverflow || false
        );
        if (intDelta != delta && fieldIndex < MILLISECONDS) {
                _add(xdate, fieldIndex+1, (delta-intDelta)*unitsWithin[fieldIndex], preventOverflow);
        }
}


function _diff(xdate1, xdate2, fieldIndex) { // fieldIndex=FULLYEAR is for years, fieldIndex=DATE is for days
        xdate1 = xdate1.clone().setUTCMode(true, true);
        xdate2 = XDate(xdate2).setUTCMode(true, true);
        var v = 0;
        if (fieldIndex == FULLYEAR || fieldIndex == MONTH) {
                for (var i=MILLISECONDS, methodName; i>=fieldIndex; i--) {
                        v /= unitsWithin[i];
                        v += _getField(xdate2, false, i) - _getField(xdate1, false, i);
                }
                if (fieldIndex == MONTH) {
                        v += (xdate2.getFullYear() - xdate1.getFullYear()) * 12;
                }
        }
        else if (fieldIndex == DATE) {
                var clear1 = xdate1.toDate().setUTCHours(0, 0, 0, 0); // returns an ms value
                var clear2 = xdate2.toDate().setUTCHours(0, 0, 0, 0); // returns an ms value
                v = Math.round((clear2 - clear1) / DAY_MS) + ((xdate2 - clear2) - (xdate1 - clear1)) / DAY_MS;
        }
        else {
                v = (xdate2 - xdate1) / [
                        3600000, // milliseconds in hour
                        60000,   // milliseconds in minute
                        1000,    // milliseconds in second
                        1        //
                        ][fieldIndex - 3];
        }
        return v;
}



/* Week Methods
---------------------------------------------------------------------------------*/


proto.getWeek = function() {
        return _getWeek(curry(_getField, this, false));
};


proto.getUTCWeek = function() {
        return _getWeek(curry(_getField, this, true));
};


proto.setWeek = function(n, year) {
        _setWeek(this, n, year, false);
        return this; // for chaining
};


proto.setUTCWeek = function(n, year) {
        _setWeek(this, n, year, true);
        return this; // for chaining
};


proto.addWeeks = function(delta) {
        return this.addDays(Number(delta) * 7);
};


proto.diffWeeks = function(otherDate) {
        return _diff(this, otherDate, DATE) / 7;
};


function _getWeek(getField) {
        return getWeek(getField(FULLYEAR), getField(MONTH), getField(DATE));
}


function getWeek(year, month, date) {
        var d = new Date(UTC(year, month, date));
        var week1 = getWeek1(
                getWeekYear(year, month, date)
        );
        return Math.floor(Math.round((d - week1) / DAY_MS) / 7) + 1;
}


function getWeekYear(year, month, date) { // get the year that the date's week # belongs to
        var d = new Date(UTC(year, month, date));
        if (d < getWeek1(year)) {
                return year - 1;
        }
        else if (d >= getWeek1(year + 1)) {
                return year + 1;
        }
        return year;
}


function getWeek1(year) { // returns Date of first week of year, in UTC
        var d = new Date(UTC(year, 0, 4));
        d.setUTCDate(d.getUTCDate() - (d.getUTCDay() + 6) % 7); // make it Monday of the week
        return d;
}


function _setWeek(xdate, n, year, useUTC) {
        var getField = curry(_getField, xdate, useUTC);
        var setField = curry(_setField, xdate, useUTC);

        if (year === undefined) {
                year = getWeekYear(
                        getField(FULLYEAR),
                        getField(MONTH),
                        getField(DATE)
                );
        }

        var week1 = getWeek1(year);
        if (!useUTC) {
                week1 = coerceToLocal(week1);
        }

        xdate.setTime(+week1);
        setField(DATE, [ getField(DATE) + (n-1) * 7 ]); // would have used xdate.addUTCWeeks :(
                // n-1 because n is 1-based
}



/* Parsing
---------------------------------------------------------------------------------*/


XDate.parsers = [
        parseISO
];


XDate.parse = function(str) {
        return +XDate(''+str);
};


function parse(str, utcMode, xdate) {
        var parsers = XDate.parsers;
        var i = 0;
        var res;
        for (; i<parsers.length; i++) {
                res = parsers[i](str, utcMode, xdate);
                if (res) {
                        return res;
                }
        }
        xdate[0] = new Date(str);
        return xdate;
}


function parseISO(str, utcMode, xdate) {
        var m = str.match(/^(\d{4})(-(\d{2})(-(\d{2})([T ](\d{2}):(\d{2})(:(\d{2})(\.(\d+))?)?(Z|(([-+])(\d{2})(:?(\d{2}))?))?)?)?)?$/);
        if (m) {
                var d = new Date(UTC(
                        m[1],
                        m[3] ? m[3] - 1 : 0,
                        m[5] || 1,
                        m[7] || 0,
                        m[8] || 0,
                        m[10] || 0,
                        m[12] ? Number('0.' + m[12]) * 1000 : 0
                ));
                if (m[13]) { // has gmt offset or Z
                        if (m[14]) { // has gmt offset
                                d.setUTCMinutes(
                                        d.getUTCMinutes() +
                                        (m[15] == '-' ? 1 : -1) * (Number(m[16]) * 60 + (m[18] ? Number(m[18]) : 0))
                                );
                        }
                }else{ // no specified timezone
                        if (!utcMode) {
                                d = coerceToLocal(d);
                        }
                }
                return xdate.setTime(+d);
        }
}



/* Formatting
---------------------------------------------------------------------------------*/


proto.toString = function(formatString, settings, uniqueness) {
        if (formatString === undefined || !valid(this)) {
                return this[0].toString(); // already accounts for utc-mode (might be toUTCString)
        }else{
                return format(this, formatString, settings, uniqueness, getUTCMode(this));
        }
};


proto.toUTCString = proto.toGMTString = function(formatString, settings, uniqueness) {
        if (formatString === undefined || !valid(this)) {
                return this[0].toUTCString();
        }else{
                return format(this, formatString, settings, uniqueness, true);
        }
};


proto.toISOString = function() {
        return this.toUTCString(ISO_FORMAT_STRING_TZ);
};


XDate.defaultLocale = '';
XDate.locales = {
        '': {
                monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December'],
                monthNamesShort: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'],
                dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
                dayNamesShort: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
                amDesignator: 'AM',
                pmDesignator: 'PM'
        }
};
XDate.formatters = {
        i: ISO_FORMAT_STRING,
        u: ISO_FORMAT_STRING_TZ
};


function format(xdate, formatString, settings, uniqueness, useUTC) {

        var locales = XDate.locales;
        var defaultLocaleSettings = locales[XDate.defaultLocale] || {};
        var getField = curry(_getField, xdate, useUTC);
        
        settings = (isString(settings) ? locales[settings] : settings) || {};
        
        function getSetting(name) {
                return settings[name] || defaultLocaleSettings[name];
        }
        
        function getFieldAndTrace(fieldIndex) {
                if (uniqueness) {
                        var i = (fieldIndex == DAY ? DATE : fieldIndex) - 1;
                        for (; i>=0; i--) {
                                uniqueness.push(getField(i));
                        }
                }
                return getField(fieldIndex);
        }
        
        return _format(xdate, formatString, getFieldAndTrace, getSetting, useUTC);
}


function _format(xdate, formatString, getField, getSetting, useUTC) {
        var m;
        var subout;
        var out = '';
        while (m = formatString.match(formatStringRE)) {
                out += formatString.substr(0, m.index);
                if (m[1]) { // consecutive alphabetic characters
                        out += processTokenString(xdate, m[1], getField, getSetting, useUTC);
                }
                else if (m[3]) { // parenthesis
                        subout = _format(xdate, m[4], getField, getSetting, useUTC);
                        if (parseInt(subout.replace(/\D/g, ''), 10)) { // if any of the numbers are non-zero. or no numbers at all
                                out += subout;
                        }
                }
                else { // else if (m[6]) { // single quotes
                        out += m[7] || "'"; // if inner is blank, meaning 2 consecutive quotes = literal single quote
                }
                formatString = formatString.substr(m.index + m[0].length);
        }
        return out + formatString;
}


function processTokenString(xdate, tokenString, getField, getSetting, useUTC) {
        var end = tokenString.length;
        var replacement;
        var out = '';
        while (end > 0) {
                replacement = getTokenReplacement(xdate, tokenString.substr(0, end), getField, getSetting, useUTC);
                if (replacement !== undefined) {
                        out += replacement;
                        tokenString = tokenString.substr(end);
                        end = tokenString.length;
                }else{
                        end--;
                }
        }
        return out + tokenString;
}


function getTokenReplacement(xdate, token, getField, getSetting, useUTC) {
        var formatter = XDate.formatters[token];
        if (isString(formatter)) {
                return _format(xdate, formatter, getField, getSetting, useUTC);
        }
        else if (isFunction(formatter)) {
                return formatter(xdate, useUTC || false, getSetting);
        }
        switch (token) {
                case 'fff'  : return zeroPad(getField(MILLISECONDS), 3);
                case 's'    : return getField(SECONDS);
                case 'ss'   : return zeroPad(getField(SECONDS));
                case 'm'    : return getField(MINUTES);
                case 'mm'   : return zeroPad(getField(MINUTES));
                case 'h'    : return getField(HOURS) % 12 || 12;
                case 'hh'   : return zeroPad(getField(HOURS) % 12 || 12);
                case 'H'    : return getField(HOURS);
                case 'HH'   : return zeroPad(getField(HOURS));
                case 'd'    : return getField(DATE);
                case 'dd'   : return zeroPad(getField(DATE));
                case 'ddd'  : return getSetting('dayNamesShort')[getField(DAY)] || '';
                case 'dddd' : return getSetting('dayNames')[getField(DAY)] || '';
                case 'M'    : return getField(MONTH) + 1;
                case 'MM'   : return zeroPad(getField(MONTH) + 1);
                case 'MMM'  : return getSetting('monthNamesShort')[getField(MONTH)] || '';
                case 'MMMM' : return getSetting('monthNames')[getField(MONTH)] || '';
                case 'yy'   : return (getField(FULLYEAR)+'').substring(2);
                case 'yyyy' : return getField(FULLYEAR);
                case 't'    : return _getDesignator(getField, getSetting).substr(0, 1).toLowerCase();
                case 'tt'   : return _getDesignator(getField, getSetting).toLowerCase();
                case 'T'    : return _getDesignator(getField, getSetting).substr(0, 1);
                case 'TT'   : return _getDesignator(getField, getSetting);
                case 'z'    :
                case 'zz'   :
                case 'zzz'  : return useUTC ? 'Z' : _getTZString(xdate, token);
                case 'w'    : return _getWeek(getField);
                case 'ww'   : return zeroPad(_getWeek(getField));
                case 'S'    :
                        var d = getField(DATE);
                        if (d > 10 && d < 20) return 'th';
                        return ['st', 'nd', 'rd'][d % 10 - 1] || 'th';
        }
}


function _getTZString(xdate, token) {
        var tzo = xdate.getTimezoneOffset();
        var sign = tzo < 0 ? '+' : '-';
        var hours = Math.floor(Math.abs(tzo) / 60);
        var minutes = Math.abs(tzo) % 60;
        var out = hours;
        if (token == 'zz') {
                out = zeroPad(hours);
        }
        else if (token == 'zzz') {
                out = zeroPad(hours) + ':' + zeroPad(minutes);
        }
        return sign + out;
}


function _getDesignator(getField, getSetting) {
        return getField(HOURS) < 12 ? getSetting('amDesignator') : getSetting('pmDesignator');
}



/* Misc Methods
---------------------------------------------------------------------------------*/


each(
        [ // other getters
                'getTime',
                'valueOf',
                'toDateString',
                'toTimeString',
                'toLocaleString',
                'toLocaleDateString',
                'toLocaleTimeString',
                'toJSON'
        ],
        function(methodName) {
                proto[methodName] = function() {
                        return this[0][methodName]();
                };
        }
);


proto.setTime = function(t) {
        this[0].setTime(t);
        return this; // for chaining
};


proto.valid = methodize(valid);
function valid(xdate) {
        return !isNaN(+xdate[0]);
}


proto.clone = function() {
        return new XDate(this);
};


proto.clearTime = function() {
        return this.setHours(0, 0, 0, 0); // will return an XDate for chaining
};


proto.toDate = function() {
        return new Date(+this[0]);
};



/* Misc Class Methods
---------------------------------------------------------------------------------*/


XDate.now = function() {
        return +new Date();
};


XDate.today = function() {
        return new XDate().clearTime();
};


XDate.UTC = UTC;


XDate.getDaysInMonth = getDaysInMonth;



/* Internal Utilities
---------------------------------------------------------------------------------*/


function _clone(xdate) { // returns the internal Date object that should be used
        var d = new Date(+xdate[0]);
        if (getUTCMode(xdate)) {
                d.toString = toUTCString;
        }
        return d;
}


function _getField(d, useUTC, fieldIndex) {
        return d['get' + (useUTC ? 'UTC' : '') + methodSubjects[fieldIndex]]();
}


function _setField(d, useUTC, fieldIndex, args) {
        d['set' + (useUTC ? 'UTC' : '') + methodSubjects[fieldIndex]].apply(d, args);
}



/* Date Math Utilities
---------------------------------------------------------------------------------*/


function coerceToUTC(date) {
        return new Date(UTC(
                date.getFullYear(),
                date.getMonth(),
                date.getDate(),
                date.getHours(),
                date.getMinutes(),
                date.getSeconds(),
                date.getMilliseconds()
        ));
}


function coerceToLocal(date) {
        return new Date(
                date.getUTCFullYear(),
                date.getUTCMonth(),
                date.getUTCDate(),
                date.getUTCHours(),
                date.getUTCMinutes(),
                date.getUTCSeconds(),
                date.getUTCMilliseconds()
        );
}


function getDaysInMonth(year, month) {
        return 32 - new Date(UTC(year, month, 32)).getUTCDate();
}



/* General Utilities
---------------------------------------------------------------------------------*/


function methodize(f) {
        return function() {
                return f.apply(undefined, [this].concat(slice(arguments)));
        };
}


function curry(f) {
        var firstArgs = slice(arguments, 1);
        return function() {
                return f.apply(undefined, firstArgs.concat(slice(arguments)));
        };
}


function slice(a, start, end) {
        return Array.prototype.slice.call(
                a,
                start || 0, // start and end cannot be undefined for IE
                end===undefined ? a.length : end
        );
}


function each(a, f) {
        for (var i=0; i<a.length; i++) {
                f(a[i], i);
        };
}


function isString(arg) {
        return typeof arg == 'string';
}


function isNumber(arg) {
        return typeof arg == 'number';
}


function isBoolean(arg) {
        return typeof arg == 'boolean';
}


function isFunction(arg) {
        return typeof arg == 'function';
}


function zeroPad(n, len) {
        len = len || 2;
        n += '';
        while (n.length < len) {
                n = '0' + n;
        }
        return n;
}



// Export for Node.js
if (typeof module !== 'undefined' && module.exports) {
        module.exports = XDate;
}

// AMD
if (typeof define === 'function' && define.amd) {
        define([], function() {
                return XDate;
        });
}


return XDate;

})(Date, Math, Array);
</script>


<!-- Jacob Wright -->
<script>
Date.prototype.jwFormat = function(format) {
    var returnStr = '';
    var replace = Date.replaceChars;
    for (var i = 0; i < format.length; i++) {       var curChar = format.charAt(i);         if (i - 1 >= 0 && format.charAt(i - 1) == "\\") {
            returnStr += curChar;
        }
        else if (replace[curChar]) {
            returnStr += replace[curChar].call(this);
        } else if (curChar != "\\"){
            returnStr += curChar;
        }
    }
    return returnStr;
};

Date.replaceChars = {
    shortMonths: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
    longMonths: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
    shortDays: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
    longDays: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],

    // Day
    d: function() { return (this.getDate() < 10 ? '0' : '') + this.getDate(); },
    D: function() { return Date.replaceChars.shortDays[this.getDay()]; },
    j: function() { return this.getDate(); },
    l: function() { return Date.replaceChars.longDays[this.getDay()]; },
    N: function() { return this.getDay() + 1; },
    S: function() { return (this.getDate() % 10 == 1 && this.getDate() != 11 ? 'st' : (this.getDate() % 10 == 2 && this.getDate() != 12 ? 'nd' : (this.getDate() % 10 == 3 && this.getDate() != 13 ? 'rd' : 'th'))); },
    w: function() { return this.getDay(); },
    z: function() { var d = new Date(this.getFullYear(),0,1); return Math.ceil((this - d) / 86400000); }, // Fixed now
    // Week
    W: function() { var d = new Date(this.getFullYear(), 0, 1); return Math.ceil((((this - d) / 86400000) + d.getDay() + 1) / 7); }, // Fixed now
    // Month
    F: function() { return Date.replaceChars.longMonths[this.getMonth()]; },
    m: function() { return (this.getMonth() < 9 ? '0' : '') + (this.getMonth() + 1); },
    M: function() { return Date.replaceChars.shortMonths[this.getMonth()]; },
    n: function() { return this.getMonth() + 1; },
    t: function() { var d = new Date(); return new Date(d.getFullYear(), d.getMonth(), 0).getDate() }, // Fixed now, gets #days of date
    // Year
    L: function() { var year = this.getFullYear(); return (year % 400 == 0 || (year % 100 != 0 && year % 4 == 0)); },   // Fixed now
    o: function() { var d  = new Date(this.valueOf());  d.setDate(d.getDate() - ((this.getDay() + 6) % 7) + 3); return d.getFullYear();}, //Fixed now
    Y: function() { return this.getFullYear(); },
    y: function() { return ('' + this.getFullYear()).substr(2); },
    // Time
    a: function() { return this.getHours() < 12 ? 'am' : 'pm'; },
    A: function() { return this.getHours() < 12 ? 'AM' : 'PM'; },
    B: function() { return Math.floor((((this.getUTCHours() + 1) % 24) + this.getUTCMinutes() / 60 + this.getUTCSeconds() / 3600) * 1000 / 24); }, // Fixed now
    g: function() { return this.getHours() % 12 || 12; },
    G: function() { return this.getHours(); },
    h: function() { return ((this.getHours() % 12 || 12) < 10 ? '0' : '') + (this.getHours() % 12 || 12); },
    H: function() { return (this.getHours() < 10 ? '0' : '') + this.getHours(); },
    i: function() { return (this.getMinutes() < 10 ? '0' : '') + this.getMinutes(); },
    s: function() { return (this.getSeconds() < 10 ? '0' : '') + this.getSeconds(); },
    u: function() { var m = this.getMilliseconds(); return (m < 10 ? '00' : (m < 100 ?
'0' : '')) + m; },
    // Timezone
    e: function() { return "Not Yet Supported"; },
    I: function() { return "Not Yet Supported"; },
    O: function() { return (-this.getTimezoneOffset() < 0 ? '-' : '+') + (Math.abs(this.getTimezoneOffset() / 60) < 10 ? '0' : '') + (Math.abs(this.getTimezoneOffset() / 60)) + '00'; },
    P: function() { return (-this.getTimezoneOffset() < 0 ? '-' : '+') + (Math.abs(this.getTimezoneOffset() / 60) < 10 ? '0' : '') + (Math.abs(this.getTimezoneOffset() / 60)) + ':00'; }, // Fixed now
    T: function() { var m = this.getMonth(); this.setMonth(0); var result = this.toTimeString().replace(/^.+ \(?([^\)]+)\)?$/, '$1'); this.setMonth(m); return result;},
    Z: function() { return -this.getTimezoneOffset() * 60; },
    // Full Date/Time
    c: function() { return this.format("Y-m-d\\TH:i:sP"); }, // Fixed now
    r: function() { return this.toString(); },
    U: function() { return this.getTime() / 1000; }
};
</script>

Test runner

Ready to run.

Testing in
TestOps/sec
sugar format
(new Date()).format("long");
ready
moment
moment().format('MMMM D, YYYY h:mma')
ready
XDate
new XDate().toString("MMMM d, yyyy h:mmtt")
ready
jwFormat
(new Date()).jwFormat('F j, Y g:i:sa');
ready

Revisions

You can edit these tests or add more tests to this page by appending /edit to the URL.