Raise 10 to a power in javascript, are there better ways than this

I have a need to create an integer value to a specific power (that’s not the correct term, but basically I need to create 10, 100, 1000, etc.) The “power” will be specified as a function parameter. I came up with a solution but MAN does it feel hacky and wrong. I’d like to learn a better way if there is one, maybe one that isn’t string based? Also, eval() is not an option.

Here is what I have at this time:

function makeMultiplierBase(precision)
    var numToParse="1";
    for(var i = 0; i < precision; i++)
        numToParse += '0';

    return parseFloat(numToParse);

I also just came up with this non-string based solution, but still seems hacky due to the loop:

function a(precision)
    var tmp = 10;
    for(var i = 1; i < precision; i++)
        tmp *= 10;

    return tmp;

BTW, I needed to do this to create a rounding method for working with currency. I had been using
var formatted = Math.round(value * 100) / 100

but this code was showing up all over the place and I wanted to have a method take care of the rounding to a specific precision so I created this

    Math.roundToPrecision = function(value, precision)
        Guard.NotNull(value, 'value');

        b = Math.pow(10, precision);
        return Math.round(value * b) / b;

Thought I’d include this here as it’s proven to be handy already.

In ES5 and earlier, use Math.pow:

var result = Math.pow(10, precision);

var precision = 5;
var result = Math.pow(10, precision);

In ES2016 and later, use the exponentiation operator:

let result = 10 ** precision;

let precision = 5;
let result = 10 ** precision;

Why not:

function precision(x) {  
  return Math.pow(10, x);

This has the same result as your function, but i still don’t understand the application/intention.

function makeMultiplierBase(precision,base){
    return Math.pow(base||10,precision);

For powers at 10³³ and above, Math.pow() may lose precision. For example:

Math.pow(10, 33);    //-> 1.0000000000000001e+33
Math.pow(10, 34);    //-> 1.0000000000000001e+34
Math.pow(10, 35);    //-> 1e+35
Math.pow(10, 36);    //-> 1e+36
Math.pow(10, 37);    //-> 1.0000000000000001e+37

While not an everyday problem that you may run into in JavaScript, it could be quite troublesome in some situations, particularly with comparison operators. One example is Google’s log10Floor() function from the Closure Library:

 * Returns the precise value of floor(log10(num)).
 * Simpler implementations didn't work because of floating point rounding
 * errors. For example
 * <ul>
 * <li>Math.floor(Math.log(num) / Math.LN10) is off by one for num == 1e+3.
 * <li>Math.floor(Math.log(num) * Math.LOG10E) is off by one for num == 1e+15.
 * <li>Math.floor(Math.log10(num)) is off by one for num == 1e+15 - 1.
 * </ul>
 * @param {number} num A floating point number.
 * @return {number} Its logarithm to base 10 rounded down to the nearest
 *     integer if num > 0. -Infinity if num == 0. NaN if num < 0.
goog.math.log10Floor = function(num) {
  if (num > 0) {
    var x = Math.round(Math.log(num) * Math.LOG10E);
    return x - (Math.pow(10, x) > num);
  return num == 0 ? -Infinity : NaN;

If you pass a power of 10 above 10³³, this function could return an incorrect result because Math.pow(10, 33) > 1e33 evaluates to true. The way I worked around this is to use Number coercion, concatenating the exponent to ‘1e’:

+'1e33'    //-> 1e+33
+'1e34'    //-> 1e+34
+'1e35'    //-> 1e+35
+'1e36'    //-> 1e+36
+'1e37'    //-> 1e+37

And, fixing the log10Floor() function:

goog.math.log10Floor = function(num) {
  if (num > 0) {
    var x = Math.round(Math.log(num) * Math.LOG10E);
    return x - (+('1e' + x) > num);
  return num == 0 ? -Infinity : NaN;

Note: The bug in closure library has since been fixed.

Read More:   Upload File as a Form Data through chrome extension

I just stumbled on something while going through https://github.com/aecostas/huffman. The compiled code(js) has a line

alphabet_next = sorted.slice(0, +(sorted.length - 1 - groupsize) + 1 || 9e9);

If you try to evaluate 9e9 (on the node and browser console) it gives you 9000000000 which is “9*10^9”.Based on that you could simply do the below to get the 10th power.

var n = 2;
eval("1e"+n); //outputs 100

EDIT: More on exponential notation from

There are two decimal notations used by JavaScript: Fixed notation
[ “+” | “-” ] digit+ [ “.” digit+ ]
and exponential notation
[ “+” | “-” ] digit [ “.” digit+ ] “e” [ “+” | “-” ] digit+
An example of exponential notation is -1.37e+2. For output, there is always exactly one digit before the point, for input you can use more than one digit. Exponential notation is interpreted as follows: Given a number in exponential notation:
significand e exponent.
The value of that number is
significand × 10exponent.
Hence, -1.37e+2 represents the number −137.

Use a lookup table. But if this is for rounding currency amounts, you should be using BigDecimal instead of the entire schemozzle.

The answers/resolutions are collected from stackoverflow, are licensed under cc by-sa 2.5 , cc by-sa 3.0 and cc by-sa 4.0 .

Similar Posts