Ways to 0-pad a number (v21)

Revision 21 of this benchmark created on


Description

There are lots of ways to zero-pad a number in JavaScript. Which is fastest?

(improved loop performance when at least one zero will be added) functions are placed into obj. to even the tests against the one that uses it as a method instead of a global function like the others.

Setup

/**
     * Pad a number with leading zeros to "pad" places:
     *
     * @param number: The number to pad
     * @param pad: The maximum number of leading zeros
     */
    var obj={};
    
    obj.padNumberMath= function(number, pad) {"use strict";
        var N = Math.pow(10, pad);
        return number < N ? ("" + (N + number)).slice(1) : "" + number;
    };
    
    obj.padNumberArray= function(n, len) {"use strict";
      return (new Array(len + 1).join('0') + n).slice(-len);
    };
    
    obj.padNumberLoop= function(number, length) {"use strict";
        var my_string = '' + number;
        for (var to_add = length - my_string.length; to_add > 0; to_add -= 1) {
            my_string = '0' + my_string;
        }
        return my_string;
    };
    
    const sliceFuncSTRING= '00000000000000000000000000000000000000000';
    obj.sliceFunc= function(number,pad) {"use strict";
     var my_string = '' + number;
        return sliceFuncSTRING.slice(my_string.length,pad) + my_string;
    };
    
    obj.padNumberLoo2= function(number, length) {"use strict";
        var my_string = ''+number;
        for (var to_add = length - my_string.length; to_add > 0; --to_add) {
            my_string = '0' + my_string;
        }
        return my_string;
    };
    
    obj.concatFunc2= function(number, length) {"use strict";
        var my_string='';
        for (var i=(number+'').length; i<length; ++i) {
            my_string+= '0';
        }
        return my_string + number;
    };
    
    obj.concatFunc3= function(number, length) {"use strict";
        number+='';
        var my_string='';
        for (var i=number.length; i<length; ++i) {
            my_string+= '0';
        }
        return my_string + number;
    };
    
    Number.prototype.pad= function(length){"use strict";
    var my_string= ''+this;
        for (var i= my_string.length,s=''; i<length; ++i) {
            s+= '0';
        }
        return s + my_string;
    };
    
    String.pad=function(s,char,length){"use strict";
        s = '' + s;
        for (var to_add = length - s.length; to_add > 0; to_add -= 1) {
            s = char + s;
        }
        return s;
    }
    
    String.prototype.pad=function(char,length){"use strict";
            var s = this;
            for (var to_add = length - s.length; to_add > 0; --to_add) {
                s = char + s;
            }
            return s;
        }

Test runner

Ready to run.

Testing in
TestOps/sec
Math
obj.padNumberMath(1301, 4);
obj.padNumberMath(120, 4);
obj.padNumberMath(14, 4);
obj.padNumberMath(9, 4);
ready
Array join
obj.padNumberArray(1301, 4);
obj.padNumberArray(120, 4);
obj.padNumberArray(14, 4);
obj.padNumberArray(9, 4);
ready
Loop concat
obj.padNumberLoop(1301, 4);
obj.padNumberLoop(120, 4);
obj.padNumberLoop(14, 4);
obj.padNumberLoop(9, 4);
ready
.slice()
obj.sliceFunc(1301, 4);
obj.sliceFunc(120, 4);
obj.sliceFunc(14, 4);
obj.sliceFunc(9, 4);
ready
loop2 concat
obj.padNumberLoo2(1301, 4);
obj.padNumberLoo2(120, 4);
obj.padNumberLoo2(14, 4);
obj.padNumberLoo2(9, 4);
ready
concat2
obj.concatFunc2(1301, 4);
obj.concatFunc2(120, 4);
obj.concatFunc2(14, 4);
obj.concatFunc2(9, 4);
ready
Number.pad
(1301).pad(4);
(120).pad(4);
(14).pad(4);
(9).pad(4);
ready
concat3
obj.concatFunc3(1301, 4);
obj.concatFunc3(120, 4);
obj.concatFunc3(14, 4);
obj.concatFunc3(9, 4);
ready
String padding
String.pad(1301, '0', 4);
String.pad(120, '0', 4);
String.pad(14, '0', 4);
String.pad(9, '0', 4);
ready
String padding2
(1301+'').pad('0',4);
(120+'').pad('0',4);
(14+'').pad('0',4);
(9+'').pad('0',4);
ready

Revisions

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