JavaScript sprintf

Return a formatted string

function sprintf () {
    // Return a formatted string  
    // 
    // version: 1109.2015
    // discuss at: http://phpjs.org/functions/sprintf    // +   original by: Ash Searle (http://hexmen.com/blog/)
    // + namespaced by: Michael White (http://getsprink.com)
    // +    tweaked by: Jack
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +      input by: Paulo Freitas    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // +      input by: Brett Zamir (http://brett-zamir.me)
    // +   improved by: Kevin van Zonneveld (http://kevin.vanzonneveld.net)
    // *     example 1: sprintf("%01.2f", 123.1);
    // *     returns 1: 123.10    // *     example 2: sprintf("[%10s]", 'monkey');
    // *     returns 2: '[    monkey]'
    // *     example 3: sprintf("[%'#10s]", 'monkey');
    // *     returns 3: '[####monkey]'
    var regex = /%%|%(\d+\$)?([-+\'#0 ]*)(\*\d+\$|\*|\d+)?(\.(\*\d+\$|\*|\d+))?([scboxXuidfegEG])/g;    var a = arguments,
        i = 0,
        format = a[i++];
 
    // pad()    var pad = function (str, len, chr, leftJustify) {
        if (!chr) {
            chr = ' ';
        }
        var padding = (str.length >= len) ? '' : Array(1 + len - str.length >>> 0).join(chr);        return leftJustify ? str + padding : padding + str;
    };
 
    // justify()
    var justify = function (value, prefix, leftJustify, minWidth, zeroPad, customPadChar) {        var diff = minWidth - value.length;
        if (diff > 0) {
            if (leftJustify || !zeroPad) {
                value = pad(value, minWidth, customPadChar, leftJustify);
            } else {                value = value.slice(0, prefix.length) + pad('', diff, '0', true) + value.slice(prefix.length);
            }
        }
        return value;
    }; 
    // formatBaseX()
    var formatBaseX = function (value, base, prefix, leftJustify, minWidth, precision, zeroPad) {
        // Note: casts negative numbers to positive ones
        var number = value >>> 0;        prefix = prefix && number && {
            '2': '0b',
            '8': '0',
            '16': '0x'
        }[base] || '';        value = prefix + pad(number.toString(base), precision || 0, '0', false);
        return justify(value, prefix, leftJustify, minWidth, zeroPad);
    };
 
    // formatString()    var formatString = function (value, leftJustify, minWidth, precision, zeroPad, customPadChar) {
        if (precision != null) {
            value = value.slice(0, precision);
        }
        return justify(value, '', leftJustify, minWidth, zeroPad, customPadChar);    };
 
    // doFormat()
    var doFormat = function (substring, valueIndex, flags, minWidth, _, precision, type) {
        var number;        var prefix;
        var method;
        var textTransform;
        var value;
         if (substring == '%%') {
            return '%';
        }
 
        // parse flags        var leftJustify = false,
            positivePrefix = '',
            zeroPad = false,
            prefixBaseX = false,
            customPadChar = ' ';        var flagsl = flags.length;
        for (var j = 0; flags && j < flagsl; j++) {
            switch (flags.charAt(j)) {
            case ' ':
                positivePrefix = ' ';                break;
            case '+':
                positivePrefix = '+';
                break;
            case '-':                leftJustify = true;
                break;
            case "'":
                customPadChar = flags.charAt(j + 1);
                break;            case '0':
                zeroPad = true;
                break;
            case '#':
                prefixBaseX = true;                break;
            }
        }
 
        // parameters may be null, undefined, empty-string or real valued        // we want to ignore null, undefined and empty-string values
        if (!minWidth) {
            minWidth = 0;
        } else if (minWidth == '*') {
            minWidth = +a[i++];        } else if (minWidth.charAt(0) == '*') {
            minWidth = +a[minWidth.slice(1, -1)];
        } else {
            minWidth = +minWidth;
        } 
        // Note: undocumented perl feature:
        if (minWidth < 0) {
            minWidth = -minWidth;
            leftJustify = true;        }
 
        if (!isFinite(minWidth)) {
            throw new Error('sprintf: (minimum-)width must be finite');
        } 
        if (!precision) {
            precision = 'fFeE'.indexOf(type) > -1 ? 6 : (type == 'd') ? 0 : undefined;
        } else if (precision == '*') {
            precision = +a[i++];        } else if (precision.charAt(0) == '*') {
            precision = +a[precision.slice(1, -1)];
        } else {
            precision = +precision;
        } 
        // grab value using valueIndex if required?
        value = valueIndex ? a[valueIndex.slice(0, -1)] : a[i++];
 
        switch (type) {        case 's':
            return formatString(String(value), leftJustify, minWidth, precision, zeroPad, customPadChar);
        case 'c':
            return formatString(String.fromCharCode(+value), leftJustify, minWidth, precision, zeroPad);
        case 'b':            return formatBaseX(value, 2, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
        case 'o':
            return formatBaseX(value, 8, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
        case 'x':
            return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad);        case 'X':
            return formatBaseX(value, 16, prefixBaseX, leftJustify, minWidth, precision, zeroPad).toUpperCase();
        case 'u':
            return formatBaseX(value, 10, prefixBaseX, leftJustify, minWidth, precision, zeroPad);
        case 'i':        case 'd':
            number = (+value) | 0;
            prefix = number < 0 ? '-' : positivePrefix;
            value = prefix + pad(String(Math.abs(number)), precision, '0', false);
            return justify(value, prefix, leftJustify, minWidth, zeroPad);        case 'e':
        case 'E':
        case 'f':
        case 'F':
        case 'g':        case 'G':
            number = +value;
            prefix = number < 0 ? '-' : positivePrefix;
            method = ['toExponential', 'toFixed', 'toPrecision']['efg'.indexOf(type.toLowerCase())];
            textTransform = ['toString', 'toUpperCase']['eEfFgG'.indexOf(type) % 2];            value = prefix + Math.abs(number)[method](precision);
            return justify(value, prefix, leftJustify, minWidth, zeroPad)[textTransform]();
        default:
            return substring;
        }    };
 
    return format.replace(regex, doFormat);
}

external links: original PHP docs | raw js source

Examples

» Example 1

Running

1	sprintf("%01.2f", 123.1);

Should return

123.10

» Example 2

Running

1	sprintf("[%10s]", 'monkey');

Should return

1	'[ monkey]'

Dependencies

No dependencies, you can use this function standalone.

Open syntax issues

php.js uses JsLint to help us keep our code consistent and prevent some common bugs.

Eventually we want all code to pass or at least take into consideration most fixes suggested by JsLint, following this JsLint configuration we’ve decided on.

Authors

Thanks to the following developers, you get to have sprintf goodness in JavaScript.

Ash Searle ( original )
Michael White ( namespaced )
Jack ( tweaked )
Kevin van Zonneveld ( improved )
Paulo Freitas ( input )
Brett Zamir ( input )

Comments

Add Comment

Name

Website

Title

Content

Use:

[CODE]
your_stuff('here');
[/CODE]

for proper code formatting
By submitting code here you are allowing us to use it in php.js hence dual licensing it under the MIT and GPL licenses

Brent
29 Sep '11

As far as adding a thousands separator, I don't think it is currently in the sprintf function code above.

However, this regex does it:

s/\d{1,3}(?=(\d{3})+(?!\d))/$&,/g

This javascript code (based on the regex) does it:





    function thousands (a){

    

     return a.replace (/\d{1,3}(?=(\d{3})+(?!\d))/g,"$&,");

     

    }

The only flaw is that it will happily keep adding commas every three characters to the right of the decimal point as well as to the left. So you have to apply it to only the integer side of the number. It works fine as-is for integers and, for example, currency (which only has max 2 decimal places).

If you want to use another separator character than "," make the change in the second argument to a.replace.

I can't quite see how to easily add this to the sprintf function (and also the usual flag to add the thousands separator is ', which is used for something else in the code above) but there is a start for anyone who like to do it.

Regex source is from: http://remysharp.com/2007/10/19/thousand-separator-regex/

Rafał Kukawski
14 Jan '11

@Dj: Thanks for your feedback. I will add the fix today.

BTW. The same can be done without the need to call parseInt and isNaN.

number = (+value) | 0;

+value casts the data to Number, | 0 drops floating point part and if the +value gives NaN, changes it to 0.

Dj
14 Jan '11

A suggest:

check the result of parseInt() function, and set it to 0 if is NaN

case 'd':
                number = parseInt(+value, 10);
if (isNaN(number) {
    number = 0;
}

so when a %d is replaced with a non integer value, the result is 0 instead of NaN like PHP do.

Example without check NaN:
result = sprintf('Number is: %d', 'non numeric');
//result is: 'Number is NaN'

Example checking NaN:
result = sprintf('Number is: %d', 'non numeric');
//result is: 'Number is 0'

try it in php and compare

kernel
9 Oct '10

please consult this project, that will be helpful

http://www.diveintojavascript.com/projects/javascript-sprintf

Brett Zamir
30 Aug '09

@Sandro Franchi: Good catch... But shouldn't it be:

if (precision !== undefined) {

? If it is as you had it, 0 will also be ignored.

Sandro Franchi
29 Aug '09

In Line 054

if (precision != null) {...

should be changed to

if (precision) {...

because precision (when not used) is "undefined", not null, also this helps to make the script validated by jslint.

Kevin van Zonneveld
8 Jan '09

@ ejsanders: Very well, thank you!

ejsanders
8 Jan '09

Here is the related function vsprintf, which takes the arguments as an array (can be useful):

[CODE="Javascript"]
function vsprintf(format, args) {
return sprintf.apply(this, [format].concat(args));
}
[/CODE]

Kevin van Zonneveld
1 Dec '08

@ Paulo Ricardo F. Santos: Fixed it, thanks for pointing that out.

Paulo Ricardo F. Santos
28 Nov '08

Hey, the current implementation misses the custom padding character:

[CODE="php"]printf("[%'#10s]\n", $s); // use the custom padding character '#'[/CODE]

;)

Kevin van Zonneveld
9 Nov '08

@ David Portabella: I did some testing and as far as I can tell PHP itself does not support that notation. And a general rule of thumb for us is: if php doesn't do it, we don't either. This ensures maximum compatibilty. If I'm in error on this, let me know.
Otherwise, the function: number_format might be what you're looking for.

Mike
9 Nov '08

If you want to serialize strings with multibyte chars (special chars) you must replace this line:

val = "s:" + mixed_value.length + ":\"" + mixed_value + "\"";

with these:

var stringLen = encodeURIComponent(mixed_value).replace(/%../g, 'x').length
val = "s:" + stringLen + ":\"" + mixed_value + "\"";

David Portabella
4 Nov '08

Hello,

Congratulations for this great library!!

one question,
Is it possible to specify a thousand separator for sprintf?

something like
sprintf('%,.2f", 1234567.89) => "1,234,567.89"

Regards,
DAvid

Contribute a New function