# Format.js

    /**
     * @class Ext.util.Format
     * Reusable data formatting functions
     * @singleton
     */
    Ext.util.Format = function(){
        var trimRe = /^\s+|\s+$/g;
        return {
            /**
             * Truncate a string and add an ellipsis ('...') to the end if it exceeds the specified length
             * @param {String} value The string to truncate
             * @param {Number} length The maximum length to allow before truncating
             * @return {String} The converted text
             */
            ellipsis : function(value, len){
                if(value && value.length > len){
                    return value.substr(0, len-3)+"...";
                }
                return value;
            },

            /**
             * Checks a reference and converts it to empty string if it is undefined
             * @param {Mixed} value Reference to check
             * @return {Mixed} Empty string if converted, otherwise the original value
             */
            undef : function(value){
                return typeof value != "undefined" ? value : "";
            },

            /**
             * Convert certain characters (&, <, >, and ') to their HTML character equivalents for literal display in web pages.
             * @param {String} value The string to encode
             * @return {String} The encoded text
             */
            htmlEncode : function(value){
                return !value ? value : String(value).replace(/&/g, "&amp;").replace(/>/g, "&gt;").replace(/</g, "&lt;").replace(/"/g, "&quot;");
            },

            /**
             * Convert certain characters (&, <, >, and ') from their HTML character equivalents.
             * @param {String} value The string to decode
             * @return {String} The decoded text
             */
            htmlDecode : function(value){
                return !value ? value : String(value).replace(/&amp;/g, "&").replace(/&gt;/g, ">").replace(/&lt;/g, "<").replace(/&quot;/g, '"');
            },

            /**
             * Trims any whitespace from either side of a string
             * @param {String} value The text to trim
             * @return {String} The trimmed text
             */
            trim : function(value){
                return String(value).replace(trimRe, "");
            },

            /**
             * Returns a substring from within an original string
             * @param {String} value The original text
             * @param {Number} start The start index of the substring
             * @param {Number} length The length of the substring
             * @return {String} The substring
             */
            substr : function(value, start, length){
                return String(value).substr(start, length);
            },

            /**
             * Converts a string to all lower case letters
             * @param {String} value The text to convert
             * @return {String} The converted text
             */
            lowercase : function(value){
                return String(value).toLowerCase();
            },

            /**
             * Converts a string to all upper case letters
             * @param {String} value The text to convert
             * @return {String} The converted text
             */
            uppercase : function(value){
                return String(value).toUpperCase();
            },

            /**
             * Converts the first character only of a string to upper case
             * @param {String} value The text to convert
             * @return {String} The converted text
             */
            capitalize : function(value){
                return !value ? value : value.charAt(0).toUpperCase() + value.substr(1).toLowerCase();
            },

            // private
            call : function(value, fn){
                if(arguments.length > 2){
                    var args = Array.prototype.slice.call(arguments, 2);
                    args.unshift(value);
                    return eval(fn).apply(window, args);
                }else{
                    return eval(fn).call(window, value);
                }
            },

            /**
             * Format a number as US currency
             * @param {Number/String} value The numeric value to format
             * @return {String} The formatted currency string
             */
            usMoney : function(v){
                v = (Math.round((v-0)*100))/100;
                v = (v == Math.floor(v)) ? v + ".00" : ((v*10 == Math.floor(v*10)) ? v + "0" : v);
                v = String(v);
                var ps = v.split('.');
                var whole = ps[0];
                var sub = ps[1] ? '.'+ ps[1] : '.00';
                var r = /(\d+)(\d{3})/;
                while (r.test(whole)) {
                    whole = whole.replace(r, '$1' + ',' + '$2');
                }
                return "$" + whole + sub ;
            },

            /**
             * Parse a value into a formatted date using the specified format pattern.
             * @param {Mixed} value The value to format
             * @param {String} format (optional) Any valid date format string (defaults to 'm/d/Y')
             * @return {String} The formatted date string
             */
            date : function(v, format){
                if(!v){
                    return "";
                }
                if(!(v instanceof Date)){
                    v = new Date(Date.parse(v));
                }
                return v.dateFormat(format || "m/d/Y");
            },

            /**
             * Returns a date rendering function that can be reused to apply a date format multiple times efficiently
             * @param {String} format Any valid date format string
             * @return {Function} The date formatting function
             */
            dateRenderer : function(format){
                return function(v){
                    return Ext.util.Format.date(v, format);
                };
            },

            // private
            stripTagsRE : /<\/?[^>]+>/gi,

            /**
             * Strips all HTML tags
             * @param {Mixed} value The text from which to strip tags
             * @return {String} The stripped text
             */
            stripTags : function(v){
                return !v ? v : String(v).replace(this.stripTagsRE, "");
            }
        };
    }();

Ext - Copyright © 2006-2007 Ext JS, LLC
All rights reserved.